reline 0.3.5 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3654e31f9c5d1aa879ae40dfb28b8de68f2e443fac87856f2387a22d61a5b4e7
-  data.tar.gz: 0fdccab5b7cfd91274e3e4544dcca69a442176cc85e1eba382da3ffd02f9ac30
+  metadata.gz: ec7aa526103ceb5eff3fa7dbbfff8c33f296f9cfb28ec4cc925b28e649dc18c8
+  data.tar.gz: 5c86a58b7769f390a81e9f6ca19a1e64eefad4ad05091544e5a01ef752b21983
 SHA512:
-  metadata.gz: 9277033707e4a1531e8590ae6a76019c21c60da22f69ea333dcc5c3d3610499303ed7892308b6ae3b495237738344baac7a21c547a19ff77f53fecae29be9a14
-  data.tar.gz: 5f3f225d7b1ee1f0ab067d8a897366a3d3b922dcedb74ae3ec980e387ad3b520d8ab808f70d89e109d06f7e5017ab6406d30e25ed2b6678b3fc8d6c4d5cf6930
+  metadata.gz: f4e586ed0f631e402d0b4b58fb05f0eec016f1290624021e957de1ced06c15e8638dac34e91c72d4b53a83e2c6b5eb5aadec2b749271d47201773dd220c63827
+  data.tar.gz: 6dcd53d5a30722bb4884f79eb9c70f49ab267b5e285b231237d339a52efdaa597377d308a264ed2cef23802b27aabb38d5ccbfd0c2dce40d631e15a6da5ede68

data/README.md

@@ -15,7 +15,7 @@ Reline is compatible with the API of Ruby's stdlib 'readline', GNU Readline and
 
 It's compatible with the readline standard library.
 
-See [the document of readline stdlib](https://ruby-doc.org/stdlib/libdoc/readline/rdoc/Readline.html) or [bin/example](https://github.com/ruby/reline/blob/master/bin/example).
+See [the document of readline stdlib](https://ruby-doc.org/stdlib/exts/readline/Readline.html) or [bin/example](https://github.com/ruby/reline/blob/master/bin/example).
 
 ### Multi-line editing mode
 
@@ -55,6 +55,36 @@ end
 
 See also: [test/reline/yamatanooroti/multiline_repl](https://github.com/ruby/reline/blob/master/test/reline/yamatanooroti/multiline_repl)
 
+## Documentation
+
+### Reline::Face
+
+You can modify the text color and text decorations in your terminal emulator.
+See [doc/reline/face.md](./doc/reline/face.md)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/reline.
+
+### Run tests
+
+> **Note**
+> Please make sure you have `libvterm` installed for `yamatanooroti` tests (integration tests).
+
+If you use Homebrew, you can install it by running `brew install libvterm`.
+
+```bash
+WITH_VTERM=1 bundle install
+WITH_VTERM=1 bundle exec rake test test_yamatanooroti
+```
+
+## Releasing
+
+```bash
+rake release
+gh release create vX.Y.Z --generate-notes
+```
+
 ## License
 
 The gem is available as open source under the terms of the [Ruby License](https://www.ruby-lang.org/en/about/license.txt).

data/lib/reline/config.rb

@@ -1,38 +1,19 @@
 class Reline::Config
   attr_reader :test_mode
 
-  KEYSEQ_PATTERN = /\\(?:C|Control)-[A-Za-z_]|\\(?:M|Meta)-[0-9A-Za-z_]|\\(?:C|Control)-(?:M|Meta)-[A-Za-z_]|\\(?:M|Meta)-(?:C|Control)-[A-Za-z_]|\\e|\\[\\\"\'abdfnrtv]|\\\d{1,3}|\\x\h{1,2}|./
+  KEYSEQ_PATTERN = /\\(?:C|Control)-[A-Za-z_]|\\(?:M|Meta)-[0-9A-Za-z_]|\\(?:C|Control)-\\(?:M|Meta)-[A-Za-z_]|\\(?:M|Meta)-\\(?:C|Control)-[A-Za-z_]|\\e|\\[\\\"\'abdfnrtv]|\\\d{1,3}|\\x\h{1,2}|./
 
   class InvalidInputrc < RuntimeError
     attr_accessor :file, :lineno
   end
 
   VARIABLE_NAMES = %w{
-    bind-tty-special-chars
-    blink-matching-paren
-    byte-oriented
     completion-ignore-case
     convert-meta
     disable-completion
-    enable-keypad
-    expand-tilde
-    history-preserve-point
     history-size
-    horizontal-scroll-mode
-    input-meta
     keyseq-timeout
-    mark-directories
-    mark-modified-lines
-    mark-symlinked-directories
-    match-hidden-files
-    meta-flag
-    output-meta
-    page-completions
-    prefer-visible-bell
-    print-completions-horizontally
     show-all-if-ambiguous
-    show-all-if-unmodified
-    visible-stats
     show-mode-in-prompt
     vi-cmd-mode-string
     vi-ins-mode-string
@@ -48,20 +29,31 @@ class Reline::Config
   attr_accessor :autocompletion
 
   def initialize
-    @additional_key_bindings = {} # from inputrc
-    @additional_key_bindings[:emacs] = {}
-    @additional_key_bindings[:vi_insert] = {}
-    @additional_key_bindings[:vi_command] = {}
-    @oneshot_key_bindings = {}
-    @skip_section = nil
-    @if_stack = nil
+    reset_variables
+  end
+
+  def reset
+    if editing_mode_is?(:vi_command)
+      @editing_mode_label = :vi_insert
+    end
+    @oneshot_key_bindings.clear
+  end
+
+  def reset_variables
+    @additional_key_bindings = { # from inputrc
+      emacs: Reline::KeyActor::Base.new,
+      vi_insert: Reline::KeyActor::Base.new,
+      vi_command: Reline::KeyActor::Base.new
+    }
+    @oneshot_key_bindings = Reline::KeyActor::Base.new
     @editing_mode_label = :emacs
     @keymap_label = :emacs
     @keymap_prefix = []
-    @key_actors = {}
-    @key_actors[:emacs] = Reline::KeyActor::Emacs.new
-    @key_actors[:vi_insert] = Reline::KeyActor::ViInsert.new
-    @key_actors[:vi_command] = Reline::KeyActor::ViCommand.new
+    @default_key_bindings = {
+      emacs: Reline::KeyActor::Base.new(Reline::KeyActor::EMACS_MAPPING),
+      vi_insert: Reline::KeyActor::Base.new(Reline::KeyActor::VI_INSERT_MAPPING),
+      vi_command: Reline::KeyActor::Base.new(Reline::KeyActor::VI_COMMAND_MAPPING)
+    }
     @vi_cmd_mode_string = '(cmd)'
     @vi_ins_mode_string = '(ins)'
     @emacs_mode_string = '@'
@@ -70,22 +62,15 @@ class Reline::Config
     @keyseq_timeout = 500
     @test_mode = false
     @autocompletion = false
-    @convert_meta = true if seven_bit_encoding?(Reline::IOGate.encoding)
-  end
-
-  def reset
-    if editing_mode_is?(:vi_command)
-      @editing_mode_label = :vi_insert
-    end
-    @additional_key_bindings.keys.each do |key|
-      @additional_key_bindings[key].clear
-    end
-    @oneshot_key_bindings.clear
-    reset_default_key_bindings
+    @convert_meta = seven_bit_encoding?(Reline::IOGate.encoding)
+    @loaded = false
+    @enable_bracketed_paste = true
+    @show_mode_in_prompt = false
+    @default_inputrc_path = nil
   end
 
   def editing_mode
-    @key_actors[@editing_mode_label]
+    @default_key_bindings[@editing_mode_label]
   end
 
   def editing_mode=(val)
@@ -97,7 +82,11 @@ class Reline::Config
   end
 
   def keymap
-    @key_actors[@keymap_label]
+    @default_key_bindings[@keymap_label]
+  end
+
+  def loaded?
+    @loaded
   end
 
   def inputrc_path
@@ -131,6 +120,7 @@ class Reline::Config
   end
 
   def read(file = nil)
+    @loaded = true
     file ||= default_inputrc_path
     begin
       if file.respond_to?(:readlines)
@@ -151,14 +141,14 @@ class Reline::Config
 
   def key_bindings
     # The key bindings for each editing mode will be overwritten by the user-defined ones.
-    kb = @key_actors[@editing_mode_label].default_key_bindings.dup
-    kb.merge!(@additional_key_bindings[@editing_mode_label])
-    kb.merge!(@oneshot_key_bindings)
-    kb
+    Reline::KeyActor::Composite.new([@oneshot_key_bindings, @additional_key_bindings[@editing_mode_label], @default_key_bindings[@editing_mode_label]])
   end
 
   def add_oneshot_key_binding(keystroke, target)
-    @oneshot_key_bindings[keystroke] = target
+    # IRB sets invalid keystroke [Reline::Key]. We should ignore it.
+    return unless keystroke.all? { |c| c.is_a?(Integer) }
+
+    @oneshot_key_bindings.add(keystroke, target)
   end
 
   def reset_oneshot_key_bindings
@@ -166,17 +156,11 @@ class Reline::Config
   end
 
   def add_default_key_binding_by_keymap(keymap, keystroke, target)
-    @key_actors[keymap].default_key_bindings[keystroke] = target
+    @default_key_bindings[keymap].add(keystroke, target)
   end
 
   def add_default_key_binding(keystroke, target)
-    @key_actors[@keymap_label].default_key_bindings[keystroke] = target
-  end
-
-  def reset_default_key_bindings
-    @key_actors.values.each do |ka|
-      ka.reset_default_key_bindings
-    end
+    add_default_key_binding_by_keymap(@keymap_label, keystroke, target)
   end
 
   def read_lines(lines, file = nil)
@@ -190,73 +174,82 @@ class Reline::Config
         end
       end
     end
-    conditions = [@skip_section, @if_stack]
-    @skip_section = nil
-    @if_stack = []
+    if_stack = []
 
     lines.each_with_index do |line, no|
+      # Even after encoding conversion, we need to verify the encoding is valid
+      # as some invalid byte sequences might pass through the conversion.
+      unless line.valid_encoding?
+        raise InvalidInputrc, "#{file}:#{no + 1}: can't be converted to the locale #{Reline.encoding_system_needs.name}"
+      end
       next if line.match(/\A\s*#/)
 
       no += 1
 
       line = line.chomp.lstrip
       if line.start_with?('$')
-        handle_directive(line[1..-1], file, no)
+        handle_directive(line[1..-1], file, no, if_stack)
         next
       end
 
-      next if @skip_section
+      next if if_stack.any? { |_no, skip| skip }
 
       case line
-      when /^set +([^ ]+) +([^ ]+)/i
-        var, value = $1.downcase, $2
-        bind_variable(var, value)
-        next
-      when /\s*("#{KEYSEQ_PATTERN}+")\s*:\s*(.*)\s*$/o
-        key, func_name = $1, $2
-        keystroke, func = bind_key(key, func_name)
-        next unless keystroke
-        @additional_key_bindings[@keymap_label][@keymap_prefix + keystroke] = func
+      when /^set +([^ ]+) +(.+)/i
+        # value ignores everything after a space, raw_value does not.
+        var, value, raw_value = $1.downcase, $2.partition(' ').first, $2
+        bind_variable(var, value, raw_value)
+      when /^\s*(?:M|Meta)-([a-zA-Z_])\s*:\s*(.*)\s*$/o
+        bind_key("\"\\M-#$1\"", $2)
+      when /^\s*(?:C|Control)-([a-zA-Z_])\s*:\s*(.*)\s*$/o
+        bind_key("\"\\C-#$1\"", $2)
+      when /^\s*(?:(?:C|Control)-(?:M|Meta)|(?:M|Meta)-(?:C|Control))-([a-zA-Z_])\s*:\s*(.*)\s*$/o
+        bind_key("\"\\M-\\C-#$1\"", $2)
+      when /^\s*("#{KEYSEQ_PATTERN}+")\s*:\s*(.*)\s*$/o
+        bind_key($1, $2)
       end
     end
-    unless @if_stack.empty?
-      raise InvalidInputrc, "#{file}:#{@if_stack.last[1]}: unclosed if"
+    unless if_stack.empty?
+      raise InvalidInputrc, "#{file}:#{if_stack.last[0]}: unclosed if"
     end
-  ensure
-    @skip_section, @if_stack = conditions
   end
 
-  def handle_directive(directive, file, no)
+  def handle_directive(directive, file, no, if_stack)
     directive, args = directive.split(' ')
     case directive
     when 'if'
       condition = false
       case args
-      when 'mode'
+      when /^mode=(vi|emacs)$/i
+        mode = $1.downcase
+        # NOTE: mode=vi means vi-insert mode
+        mode = 'vi_insert' if mode == 'vi'
+        if @editing_mode_label == mode.to_sym
+          condition = true
+        end
       when 'term'
       when 'version'
       else # application name
         condition = true if args == 'Ruby'
         condition = true if args == 'Reline'
       end
-      @if_stack << [file, no, @skip_section]
-      @skip_section = !condition
+      if_stack << [no, !condition]
     when 'else'
-      if @if_stack.empty?
+      if if_stack.empty?
         raise InvalidInputrc, "#{file}:#{no}: unmatched else"
       end
-      @skip_section = !@skip_section
+      if_stack.last[1] = !if_stack.last[1]
     when 'endif'
-      if @if_stack.empty?
+      if if_stack.empty?
         raise InvalidInputrc, "#{file}:#{no}: unmatched endif"
       end
-      @skip_section = @if_stack.pop
+      if_stack.pop
     when 'include'
-      read(args)
+      read(File.expand_path(args))
     end
   end
 
-  def bind_variable(name, value)
+  def bind_variable(name, value, raw_value)
     case name
     when 'history-size'
       begin
@@ -264,24 +257,8 @@ class Reline::Config
       rescue ArgumentError
         @history_size = 500
       end
-    when 'bell-style'
-      @bell_style =
-        case value
-        when 'none', 'off'
-          :none
-        when 'audible', 'on'
-          :audible
-        when 'visible'
-          :visible
-        else
-          :audible
-        end
-    when 'comment-begin'
-      @comment_begin = value.dup
-    when 'completion-query-items'
-      @completion_query_items = value.to_i
     when 'isearch-terminators'
-      @isearch_terminators = retrieve_string(value)
+      @isearch_terminators = retrieve_string(raw_value)
     when 'editing-mode'
       case value
       when 'emacs'
@@ -323,11 +300,11 @@ class Reline::Config
         @show_mode_in_prompt = false
       end
     when 'vi-cmd-mode-string'
-      @vi_cmd_mode_string = retrieve_string(value)
+      @vi_cmd_mode_string = retrieve_string(raw_value)
     when 'vi-ins-mode-string'
-      @vi_ins_mode_string = retrieve_string(value)
+      @vi_ins_mode_string = retrieve_string(raw_value)
     when 'emacs-mode-string'
-      @emacs_mode_string = retrieve_string(value)
+      @emacs_mode_string = retrieve_string(raw_value)
     when *VARIABLE_NAMES then
       variable_name = :"@#{name.tr(?-, ?_)}"
       instance_variable_set(variable_name, value.nil? || value == '1' || value == 'on')
@@ -339,7 +316,12 @@ class Reline::Config
     parse_keyseq(str).map { |c| c.chr(Reline.encoding_system_needs) }.join
   end
 
-  def bind_key(key, func_name)
+  def bind_key(key, value)
+    keystroke, func = parse_key_binding(key, value)
+    @additional_key_bindings[@keymap_label].add(@keymap_prefix + keystroke, func) if keystroke
+  end
+
+  def parse_key_binding(key, func_name)
     if key =~ /\A"(.*)"\z/
       keyseq = parse_keyseq($1)
     else
@@ -348,27 +330,19 @@ class Reline::Config
     if func_name =~ /"(.*)"/
       func = parse_keyseq($1)
     else
-      func = func_name.tr(?-, ?_).to_sym # It must be macro.
+      func = func_name.split.first.tr(?-, ?_).to_sym # It must be macro.
     end
     [keyseq, func]
   end
 
   def key_notation_to_code(notation)
     case notation
+    when /(?:\\(?:C|Control)-\\(?:M|Meta)|\\(?:M|Meta)-\\(?:C|Control))-([A-Za-z_])/
+      [?\e.ord, $1.ord % 32]
     when /\\(?:C|Control)-([A-Za-z_])/
-      (1 + $1.downcase.ord - ?a.ord)
+      ($1.upcase.ord % 32)
     when /\\(?:M|Meta)-([0-9A-Za-z_])/
-      modified_key = $1
-      case $1
-      when /[0-9]/
-        ?\M-0.bytes.first + (modified_key.ord - ?0.ord)
-      when /[A-Z]/
-        ?\M-A.bytes.first + (modified_key.ord - ?A.ord)
-      when /[a-z]/
-        ?\M-a.bytes.first + (modified_key.ord - ?a.ord)
-      end
-    when /\\(?:C|Control)-(?:M|Meta)-[A-Za-z_]/, /\\(?:M|Meta)-(?:C|Control)-[A-Za-z_]/
-    # 129 M-^A
+      [?\e.ord, $1.ord]
     when /\\(\d{1,3})/ then $1.to_i(8) # octal
     when /\\x(\h{1,2})/ then $1.to_i(16) # hexadecimal
     when "\\e" then ?\e.ord
@@ -388,11 +362,14 @@ class Reline::Config
   end
 
   def parse_keyseq(str)
-    ret = []
-    str.scan(KEYSEQ_PATTERN) do
-      ret << key_notation_to_code($&)
+    str.scan(KEYSEQ_PATTERN).flat_map do |notation|
+      key_notation_to_code(notation)
     end
-    ret
+  end
+
+  def reload
+    reset_variables
+    read
   end
 
   private def seven_bit_encoding?(encoding)

data/lib/reline/face.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+class Reline::Face
+  SGR_PARAMETERS = {
+    foreground: {
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      white: 37,
+      bright_black: 90,
+      gray: 90,
+      bright_red: 91,
+      bright_green: 92,
+      bright_yellow: 93,
+      bright_blue: 94,
+      bright_magenta: 95,
+      bright_cyan: 96,
+      bright_white: 97
+    },
+    background: {
+      black: 40,
+      red: 41,
+      green: 42,
+      yellow: 43,
+      blue: 44,
+      magenta: 45,
+      cyan: 46,
+      white: 47,
+      bright_black: 100,
+      gray: 100,
+      bright_red: 101,
+      bright_green: 102,
+      bright_yellow: 103,
+      bright_blue: 104,
+      bright_magenta: 105,
+      bright_cyan: 106,
+      bright_white: 107,
+    },
+    style: {
+      reset: 0,
+      bold: 1,
+      faint: 2,
+      italicized: 3,
+      underlined: 4,
+      slowly_blinking: 5,
+      blinking: 5,
+      rapidly_blinking: 6,
+      negative: 7,
+      concealed: 8,
+      crossed_out: 9
+    }
+  }.freeze
+
+  class Config
+    ESSENTIAL_DEFINE_NAMES = %i(default enhanced scrollbar).freeze
+    RESET_SGR = "\e[0m".freeze
+
+    def initialize(name, &block)
+      @definition = {}
+      block.call(self)
+      ESSENTIAL_DEFINE_NAMES.each do |name|
+        @definition[name] ||= { style: :reset, escape_sequence: RESET_SGR }
+      end
+    end
+
+    attr_reader :definition
+
+    def define(name, **values)
+      values[:escape_sequence] = format_to_sgr(values.to_a).freeze
+      @definition[name] = values
+    end
+
+    def reconfigure
+      @definition.each_value do |values|
+        values.delete(:escape_sequence)
+        values[:escape_sequence] = format_to_sgr(values.to_a).freeze
+      end
+    end
+
+    def [](name)
+      @definition.dig(name, :escape_sequence) or raise ArgumentError, "unknown face: #{name}"
+    end
+
+    private
+
+    def sgr_rgb(key, value)
+      return nil unless rgb_expression?(value)
+      if Reline::Face.truecolor?
+        sgr_rgb_truecolor(key, value)
+      else
+        sgr_rgb_256color(key, value)
+      end
+    end
+
+    def sgr_rgb_truecolor(key, value)
+      case key
+      when :foreground
+        "38;2;"
+      when :background
+        "48;2;"
+      end + value[1, 6].scan(/../).map(&:hex).join(";")
+    end
+
+    def sgr_rgb_256color(key, value)
+      # 256 colors are
+      # 0..15: standard colors, high intensity colors
+      # 16..232: 216 colors (R, G, B each 6 steps)
+      # 233..255: grayscale colors (24 steps)
+      # This methods converts rgb_expression to 216 colors
+      rgb = value[1, 6].scan(/../).map(&:hex)
+      # Color steps are [0, 95, 135, 175, 215, 255]
+      r, g, b = rgb.map { |v| v <= 95 ? v / 48 : (v - 35) / 40 }
+      color = (16 + 36 * r + 6 * g + b)
+      case key
+      when :foreground
+        "38;5;#{color}"
+      when :background
+        "48;5;#{color}"
+      end
+    end
+
+    def format_to_sgr(ordered_values)
+      sgr = "\e[" + ordered_values.map do |key_value|
+        key, value = key_value
+        case key
+        when :foreground, :background
+          case value
+          when Symbol
+            SGR_PARAMETERS[key][value]
+          when String
+            sgr_rgb(key, value)
+          end
+        when :style
+          [ value ].flatten.map do |style_name|
+            SGR_PARAMETERS[:style][style_name]
+          end.then do |sgr_parameters|
+            sgr_parameters.include?(nil) ? nil : sgr_parameters
+          end
+        end.then do |rendition_expression|
+          unless rendition_expression
+            raise ArgumentError, "invalid SGR parameter: #{value.inspect}"
+          end
+          rendition_expression
+        end
+      end.join(';') + "m"
+      sgr == RESET_SGR ? RESET_SGR : RESET_SGR + sgr
+    end
+
+    def rgb_expression?(color)
+      color.respond_to?(:match?) and color.match?(/\A#[0-9a-fA-F]{6}\z/)
+    end
+  end
+
+  private_constant :SGR_PARAMETERS, :Config
+
+  def self.truecolor?
+    @force_truecolor || %w[truecolor 24bit].include?(ENV['COLORTERM'])
+  end
+
+  def self.force_truecolor
+    @force_truecolor = true
+    @configs&.each_value(&:reconfigure)
+  end
+
+  def self.[](name)
+    @configs[name]
+  end
+
+  def self.config(name, &block)
+    @configs ||= {}
+    @configs[name] = Config.new(name, &block)
+  end
+
+  def self.configs
+    @configs.transform_values(&:definition)
+  end
+
+  def self.load_initial_configs
+    config(:default) do |conf|
+      conf.define :default, style: :reset
+      conf.define :enhanced, style: :reset
+      conf.define :scrollbar, style: :reset
+    end
+    config(:completion_dialog) do |conf|
+      conf.define :default, foreground: :bright_white, background: :gray
+      conf.define :enhanced, foreground: :black, background: :white
+      conf.define :scrollbar, foreground: :white, background: :gray
+    end
+  end
+
+  def self.reset_to_initial_configs
+    @configs = {}
+    load_initial_configs
+  end
+end

data/lib/reline/history.rb

@@ -19,7 +19,7 @@ class Reline::History < Array
 
   def []=(index, val)
     index = check_index(index)
-    super(index, String.new(val, encoding: Reline.encoding_system_needs))
+    super(index, Reline::Unicode.safe_encode(val, Reline.encoding_system_needs))
   end
 
   def concat(*val)
@@ -45,7 +45,7 @@ class Reline::History < Array
       end
     end
     super(*(val.map{ |v|
-      String.new(v, encoding: Reline.encoding_system_needs)
+      Reline::Unicode.safe_encode(v, Reline.encoding_system_needs)
     }))
   end
 
@@ -56,13 +56,13 @@ class Reline::History < Array
     if @config.history_size.positive?
       shift if size + 1 > @config.history_size
     end
-    super(String.new(val, encoding: Reline.encoding_system_needs))
+    super(Reline::Unicode.safe_encode(val, Reline.encoding_system_needs))
   end
 
   private def check_index(index)
     index += size if index < 0
     if index < -2147483648 or 2147483647 < index
-      raise RangeError.new("integer #{index} too big to convert to `int'")
+      raise RangeError.new("integer #{index} too big to convert to 'int'")
     end
     # If history_size is negative, history size is unlimited.
     if @config.history_size.positive?