coolline 0.0.1pre

data/lib/coolline.rb

@@ -0,0 +1,7 @@
+require 'coolline/handler'
+require 'coolline/history'
+require 'coolline/editor'
+
+require 'coolline/coolline'
+
+require 'coolline/version'

data/lib/coolline/coolline.rb

@@ -0,0 +1,369 @@
+require 'io/console'
+
+class Coolline
+  if ENV["XDG_CONFIG_HOME"]
+    ConfigDir   = ENV["XDG_CONFIG_HOME"]
+    ConfigFile  = File.join(ConfigDir,  "coolline.rb")
+  else
+    ConfigDir  = ENV["HOME"]
+    ConfigFile = File.join(ConfigDir, ".coolline.rb")
+  end
+
+  HistoryFile = File.join(ConfigDir, ".coolline-history")
+
+  NullFile = "/dev/null"
+
+  AnsiCode = %r{(\e\[\??\d+(?:;\d+)?\w)}
+
+  # @return [Hash] All the defaults settings
+  Settings = {
+    :word_boundaries => [" ", "-", "_"],
+
+    :handlers =>
+     [
+      Handler.new(/\A(?:\C-h|\x7F)\z/, &:kill_backward_char),
+      Handler.new("\C-a", &:beginning_of_line),
+      Handler.new("\C-e", &:end_of_line),
+      Handler.new("\C-k", &:kill_line),
+      Handler.new("\C-f", &:forward_char),
+      Handler.new("\C-b", &:backward_char),
+      Handler.new("\C-d", &:kill_current_char),
+      Handler.new("\C-c") { Process.kill(:INT, Process.pid) },
+      Handler.new("\C-w", &:kill_backward_word),
+      Handler.new("\C-t", &:transpose_chars),
+      Handler.new("\C-n", &:next_history_line),
+      Handler.new("\C-p", &:previous_history_line),
+      Handler.new("\C-r", &:interactive_search),
+      Handler.new("\t", &:complete),
+      Handler.new("\C-a".."\C-z") {},
+
+      Handler.new(/\A\e(?:\C-h|\x7F)\z/, &:kill_backward_word),
+      Handler.new("\eb", &:backward_word),
+      Handler.new("\ef", &:forward_word),
+      Handler.new("\e[A", &:previous_history_line),
+      Handler.new("\e[B", &:next_history_line),
+      Handler.new("\e[5~", &:previous_history_line),
+      Handler.new("\e[6~", &:next_history_line),
+      Handler.new("\e[C", &:forward_char),
+      Handler.new("\e[D", &:backward_char),
+      Handler.new("\et", &:transpose_words),
+      Handler.new("\ec", &:capitalize_word),
+      Handler.new("\eu", &:uppercase_word),
+      Handler.new("\el", &:lowercase_word),
+
+      Handler.new(/\e.+/) {},
+    ],
+
+    :unknown_char_proc => :insert_string.to_proc,
+    :transform_proc    => :line.to_proc,
+    :completion_proc   => proc { |cool| [] },
+
+    :history_file => HistoryFile,
+    :history_size => 5000,
+  }
+
+  include Coolline::Editor
+
+  @config_loaded = false
+
+  # Loads the config, even if it has already been loaded
+  def self.load_config!
+    if File.exist? ConfigFile
+      load ConfigFile
+    end
+
+    @config_loaded = true
+  end
+
+  # Loads the config, unless it has already been loaded
+  def self.load_config
+    load_config! unless @config_loaded
+  end
+
+  # Creates a new cool line.
+  #
+  # @yieldparam [Coolline] self
+  def initialize
+    self.class.load_config
+
+    @input  = STDIN # must be the actual IO object
+    @output = $stdout
+
+    self.word_boundaries   = Settings[:word_boundaries].dup
+    self.handlers          = Settings[:handlers].dup
+    self.transform_proc    = Settings[:transform_proc]
+    self.unknown_char_proc = Settings[:unknown_char_proc]
+    self.completion_proc   = Settings[:completion_proc]
+    self.history_file      = Settings[:history_file]
+    self.history_size      = Settings[:history_size]
+
+    yield self if block_given?
+
+    @history ||= History.new(@history_file, @history_size)
+  end
+
+  # @return [IO]
+  attr_accessor :input, :output
+
+  # @return [Array<String, Regexp>] Expressions detected as word boundaries
+  attr_reader :word_boundaries
+
+  # @return [Regexp] Regular expression to match word boundaries
+  attr_reader :word_boundaries_regexp
+
+  def word_boundaries=(array)
+    @word_boundaries = array
+    @word_boundaries_regexp = /\A#{Regexp.union(*array)}\z/
+  end
+
+  # @return [Proc] Proc called to change the way a line is displayed
+  attr_accessor :transform_proc
+
+  # @return [Proc] Proc called to handle unmatched characters
+  attr_accessor :unknown_char_proc
+
+  # @return [Proc] Proc called to retrieve completions
+  attr_accessor :completion_proc
+
+  # @return [Array<Handler>]
+  attr_accessor :handlers
+
+  # @return [String] Name of the file containing history
+  attr_accessor :history_file
+
+  # @return [Integer] Size of the history
+  attr_accessor :history_size
+
+  # @return [History] History object
+  attr_accessor :history
+
+  # @return [String] Current line
+  attr_reader :line
+
+  # @return [Integer] Cursor position
+  attr_accessor :pos
+
+  # @return [String] Current prompt
+  attr_accessor :prompt
+
+  # Reads a line from the terminal
+  # @param [String] prompt Characters to print before each line
+  def readline(prompt = ">> ")
+    @prompt = prompt
+
+    @line        = ""
+    @pos         = 0
+    @accumulator = nil
+
+    @history_index = @history.size
+    @history_moved = false
+
+    print "\r\e[0m\e[0K"
+    print @prompt
+
+    until (char = @input.getch) == "\r"
+      handle(char)
+
+      if @history_moved
+        @history_moved = false
+      else
+        @history_index = @history.size
+      end
+
+      width       = @input.winsize[1]
+      prompt_size = strip_ansi_codes(@prompt).size
+      line        = transform(@line)
+
+      stripped_line_width = strip_ansi_codes(line).size
+      line << " " * [width - stripped_line_width - prompt_size, 0].max
+
+      # reset the color, and kill the line
+      print "\r\e[0m\e[0K"
+
+      if strip_ansi_codes(@prompt + line).size <= width
+        print @prompt + line
+        print "\e[#{prompt_size + @pos + 1}G"
+      else
+        print @prompt
+
+        left_width = width - prompt_size
+
+        start_index = [@pos - left_width + 1, 0].max
+        end_index   = start_index + left_width - 1
+
+        i = 0
+        line.split(AnsiCode).each do |str|
+          if start_with_ansi_code? str
+            # always print ansi codes to ensure the color is right
+            print str
+          else
+            if i >= start_index
+              print str[0..(end_index - i)]
+            elsif i < start_index && i + str.size >= start_index
+              print str[(start_index - i), left_width]
+            end
+
+            i += str.size
+            break if i >= end_index
+          end
+        end
+
+        if @pos < left_width + 1
+          print "\e[#{prompt_size + @pos + 1}G"
+        end
+      end
+    end
+
+    print "\n"
+
+    @history << @line
+
+    @line + "\n"
+  end
+
+  # Reads a line with no prompt
+  def gets
+    readline ""
+  end
+
+  # Prints objects to the output.
+  def print(*objs)
+    @output.print(*objs)
+  end
+
+  # Selects the previous line in history (if any)
+  def previous_history_line
+    if @history_index - 1 >= 0
+      @line.replace @history[@history_index - 1]
+      @pos = [@line.size, @pos].min
+
+      @history_index -= 1
+    end
+
+    @history_moved = true
+  end
+
+  # Selects the next line in history (if any).
+  #
+  # When on the last line, this method replaces the current line with an empty
+  # string.
+  def next_history_line
+    if @history_index + 1 <= @history.size
+      @line.replace @history[@history_index + 1] || ""
+      @pos = [@line.size, @pos].min
+
+      @history_index += 1
+    end
+
+    @history_moved = true
+  end
+
+  # Prompts the user to search for a line
+  def interactive_search
+    initial_index = @history_index
+    found_index   = @history_index
+
+    # Use another coolline instance for the search! :D
+    Coolline.new { |c|
+      # Remove the search handler (to avoid nesting confusion)
+      c.handlers.delete_if { |h| h.char == "\C-r" }
+
+      # search line
+      c.transform_proc = proc do
+        pattern = Regexp.new Regexp.escape(c.line)
+
+        line, found_index = @history.search(pattern, @history_index).first
+
+        if line
+          "#{c.line}): #{line}"
+        else
+          "#{c.line}): [pattern not found]"
+        end
+      end
+
+      # Disable history
+      c.history_file = NullFile
+      c.history_size = 0
+    }.readline("(search:")
+
+    @line.replace @history[found_index]
+    @pos = [@line.size, @pos].min
+
+    @history_index = found_index
+    @history_moved = true
+  end
+
+  # @return [String] The string to be completed (useful in the completion proc)
+  def completed_word
+    line[word_beginning_before(pos)...pos]
+  end
+
+  # Tries to complete the current word
+  def complete
+    return if word_boundary? line[pos - 1]
+
+    completions = @completion_proc.call(self)
+    return if completions.empty?
+
+    result = completions.inject do |common, el|
+      i = 0
+      i += 1 while common[i] == el[i]
+
+      el[0...i]
+    end
+
+    beg = word_beginning_before(pos)
+    line[beg...pos] = result
+    self.pos = beg + result.size
+  end
+
+  def word_boundary?(char)
+    char =~ word_boundaries_regexp
+  end
+
+  def strip_ansi_codes(string)
+    string.gsub(AnsiCode, "")
+  end
+
+  def start_with_ansi_code?(string)
+    (string =~ AnsiCode) == 0
+  end
+
+  private
+  def transform(line)
+    @transform_proc.call(line)
+  end
+
+  def handle(char)
+    input = if @accumulator
+              handle_escape(char)
+            elsif char == "\e"
+              @accumulator = "\e"
+              nil
+            else
+              char
+            end
+
+    if input
+      if handler = @handlers.find { |h| h === input }
+        handler.call self
+      else
+        @unknown_char_proc.call self, char
+      end
+    end
+  end
+
+  def handle_escape(char)
+    if char == "[" && @accumulator =~ /\A\e?\e\z/ or
+        char =~ /\d/ && @accumulator =~ /\A\e?\e\[\d*\z/ or
+        char == "\e" && @accumulator == "\e"
+      @accumulator << char
+      nil
+    else
+      str = @accumulator + char
+      @accumulator = nil
+
+      str
+    end
+  end
+end

data/lib/coolline/editor.rb

@@ -0,0 +1,227 @@
+class Coolline
+  module Editor
+    # Inserts a string at the current point in the line
+    #
+    # @param [String] string String to be inserted
+    def insert_string(string)
+      line.insert pos, string
+      self.pos += string.size
+    end
+
+    def word_boundary_after(pos)
+      pos += 1 # don't return initial pos
+      pos += 1 until pos >= line.size or word_boundary? line[pos]
+      pos >= line.size ? nil : pos
+    end
+
+    def word_boundary_before(pos)
+      pos -= 1
+      pos -= 1 until pos < 0 or word_boundary? line[pos]
+      pos < 0 ? nil : pos
+    end
+
+    def non_word_boundary_after(pos)
+      pos += 1
+      pos += 1 while pos < line.size and word_boundary? line[pos]
+      pos >= line.size ? nil : pos
+    end
+
+    def non_word_boundary_before(pos)
+      pos -= 1
+      pos -= 1 while pos >= 0 and word_boundary? line[pos]
+      pos < 0 ? nil : pos
+    end
+
+    def word_end_before(pos)
+      pos -= 1
+
+      if line[pos] and word_boundary? line[pos]
+        non_word_boundary_before(pos) || 0
+      else
+        pos
+      end
+    end
+
+    def word_beginning_before(pos)
+      word_end = word_end_before(pos)
+
+      if first = word_boundary_before(word_end)
+        first + 1
+      else
+        0
+      end
+    end
+
+    def word_beginning_after(pos)
+      if line[pos] and word_boundary? line[pos]
+        non_word_boundary_after(pos) || line.size
+      else
+        pos
+      end
+    end
+
+    def word_end_after(pos)
+      word_beg = word_beginning_after(pos)
+
+      if first = word_boundary_after(word_beg)
+        first - 1
+      else
+        line.size - 1
+      end
+    end
+
+    # Moves the cursor to the beginning of the line
+    def beginning_of_line
+      self.pos = 0
+    end
+
+    # Moves to the end of the line
+    def end_of_line
+      self.pos = line.size
+    end
+
+    # Moves to the previous character
+    def backward_char
+      self.pos -= 1 if pos != 0
+    end
+
+    # Moves to the next character
+    def forward_char
+      self.pos += 1 if pos != line.size
+    end
+
+    # Moves to the previous word
+    def backward_word
+      self.pos = word_beginning_before(pos) if pos > 0
+    end
+
+    # Moves to the next word
+    def forward_word
+      self.pos = word_end_after(pos) + 1 if pos != line.size
+    end
+
+    # Removes the previous word
+    def kill_backward_word
+      if pos > 0
+        beg = word_beginning_before(pos)
+
+        line[beg...pos] = ""
+        self.pos = beg
+      end
+    end
+
+    # Removes the previous character
+    def kill_backward_char
+      if pos > 0
+        line[pos - 1] = ""
+        self.pos -= 1
+      end
+    end
+
+    # Removes the current character
+    def kill_current_char
+      line[pos] = "" if pos != line.size
+    end
+
+    # Removes all the characters beyond the current point
+    def kill_line
+      line[pos..-1] = ""
+    end
+
+    # Swaps the previous character with the current one
+    def transpose_chars
+      if line.size >= 2
+        if pos == line.size
+          line[pos - 2], line[pos - 1] = line[pos - 1], line[pos - 2]
+        else
+          line[pos - 1], line[pos] = line[pos], line[pos - 1]
+          self.pos += 1
+        end
+      end
+    end
+
+    # Swaps the current word with the previous word, or the two previous words
+    # if we're at the end of the line.
+    def transpose_words
+      if !non_word_boundary_after(pos)
+        last = non_word_boundary_before(pos)
+        return unless last
+
+        last_beg = word_beginning_before(last)
+        return unless word_boundary_before(last_beg)
+
+        whitespace_beg = word_end_before(last_beg)
+        return unless non_word_boundary_before(whitespace_beg + 1)
+
+        first_beg = word_beginning_before(last_beg)
+
+        line[first_beg..last] = line[last_beg..last] +
+          line[(whitespace_beg + 1)...last_beg] +
+          line[first_beg..whitespace_beg]
+
+        self.pos = last + 1
+      elsif word_boundary? line[pos] # between two words?
+        return unless non_word_boundary_before(pos)
+
+        last_beg = word_beginning_after(pos)
+        last_end = word_end_after(pos)
+
+        first_end = word_end_before(pos)
+        first_beg = word_beginning_before(pos)
+
+        line[first_beg..last_end] = line[last_beg..last_end] +
+          line[(first_end + 1)...last_beg] +
+          line[first_beg..first_end]
+        self.pos = last_end + 1
+      else # within a word?
+        return unless non_word_boundary_before(pos)
+        return unless word_boundary_before(pos)
+
+        last_beg = word_beginning_after(pos - 1)
+        last_end = word_end_after(pos)
+
+        return unless non_word_boundary_before(last_beg)
+
+        first_end = word_end_before(last_beg)
+        first_beg = word_beginning_before(last_beg)
+
+        line[first_beg..last_end] = line[last_beg..last_end] +
+          line[(first_end + 1)...last_beg] +
+          line[first_beg..first_end]
+        self.pos = last_end + 1
+      end
+    end
+
+    # Capitalizes the current word
+    def capitalize_word
+      if beg = word_beginning_after(pos) and last = word_end_after(pos)
+        line[beg..last] = line[beg..last].capitalize
+        self.pos = last + 1
+      end
+    end
+
+    # Lowercases the current word
+    def lowercase_word
+      if beg = word_beginning_after(pos) and last = word_end_after(pos)
+        line[beg..last] = line[beg..last].downcase
+        self.pos = last + 1
+      end
+    end
+
+    # Uppercases the current word
+    def uppercase_word
+      if beg = word_beginning_after(pos) and last = word_end_after(pos)
+        line[beg..last] = line[beg..last].upcase
+        self.pos = last + 1
+      end
+    end
+
+    # This method can be overriden to change characters considered as word
+    # boundaries.
+    #
+    # @return [Boolean] True if the string is a word boundary, false otherwise
+    def word_boundary?(string)
+      string =~ /\A[ \t]+\z/
+    end
+  end
+end