yap-rawline 0.1.0

data/lib/rawline/prompt.rb

@@ -0,0 +1,12 @@
+require 'delegate'
+
+module RawLine
+
+  class Prompt < SimpleDelegator
+    # Length returns the length of the prompt minus any ANSI escape sequences.
+    def length
+      self.gsub(/\033\[[0-9;]*m/, "").length
+    end
+  end
+
+end

data/lib/rawline/terminal.rb

@@ -0,0 +1,161 @@
+#!usr/bin/env ruby
+
+require 'terminfo'
+require 'io/console'
+require 'ostruct'
+
+#
+#  terminal.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+#
+#
+module RawLine
+
+  #
+  # The Terminal class defines character codes and code sequences which can be
+  # bound to actions by editors.
+  # An OS-dependent subclass of RawLine::Terminal is automatically instantiated by
+  # RawLine::Editor.
+  #
+  class Terminal
+
+    include HighLine::SystemExtensions
+
+    attr_accessor :escape_codes
+    attr_reader :keys, :escape_sequences
+
+    #
+    # Create an instance of RawLine::Terminal.
+    #
+    def initialize
+      @keys =
+        {
+        :tab => [?\t.ord],
+        :return => [?\r.ord],
+        :newline => [?\n.ord],
+        :escape => [?\e.ord],
+
+        :ctrl_a => [?\C-a.ord],
+        :ctrl_b => [?\C-b.ord],
+        :ctrl_c => [?\C-c.ord],
+        :ctrl_d => [?\C-d.ord],
+        :ctrl_e => [?\C-e.ord],
+        :ctrl_f => [?\C-f.ord],
+        :ctrl_g => [?\C-g.ord],
+        :ctrl_h => [?\C-h.ord],
+        :ctrl_i => [?\C-i.ord],
+        :ctrl_j => [?\C-j.ord],
+        :ctrl_k => [?\C-k.ord],
+        :ctrl_l => [?\C-l.ord],
+        :ctrl_m => [?\C-m.ord],
+        :ctrl_n => [?\C-n.ord],
+        :ctrl_o => [?\C-o.ord],
+        :ctrl_p => [?\C-p.ord],
+        :ctrl_q => [?\C-q.ord],
+        :ctrl_r => [?\C-r.ord],
+        :ctrl_s => [?\C-s.ord],
+        :ctrl_t => [?\C-t.ord],
+        :ctrl_u => [?\C-u.ord],
+        :ctrl_v => [?\C-v.ord],
+        :ctrl_w => [?\C-w.ord],
+        :ctrl_x => [?\C-x.ord],
+        :ctrl_y => [?\C-y.ord],
+        :ctrl_z => [?\C-z.ord]
+        }
+      @escape_codes = []
+      @escape_sequences = []
+      update
+    end
+
+    CursorPosition = Struct.new(:column, :row)
+
+    def cursor_position
+      res = ''
+      $stdin.raw do |stdin|
+        $stdout << "\e[6n"
+        $stdout.flush
+        while (c = stdin.getc) != 'R'
+          res << c if c
+        end
+      end
+      m = res.match /(?<row>\d+);(?<column>\d+)/
+      CursorPosition.new(Integer(m[:column]), Integer(m[:row]))
+    end
+
+    def clear_to_beginning_of_line
+      term_info.control "el1"
+    end
+
+    def clear_screen
+      term_info.control "clear"
+    end
+
+    def clear_screen_down
+      term_info.control "ed"
+    end
+
+    def move_to_beginning_of_row
+      move_to_column 0
+    end
+
+    def move_left
+      move_left_n_characters 1
+    end
+
+    def move_left_n_characters(n)
+      n.times { term_info.control "cub1" }
+    end
+
+    def move_right_n_characters(n)
+      n.times { term_info.control "cuf1" }
+    end
+
+    def move_to_column_and_row(column, row)
+      term_info.control "cup", column, row
+    end
+
+    def move_to_column(n)
+      term_info.control "hpa", n
+    end
+
+    def move_up_n_rows(n)
+      n.times { term_info.control "cuu1" }
+    end
+
+    def move_down_n_rows(n)
+      n.times { term_info.control "cud1" }
+    end
+
+    def preserve_cursor(&blk)
+      term_info.control "sc" # store cursor position
+      blk.call
+    ensure
+      term_info.control "rc" # restore cursor position
+    end
+
+    #
+    # Update the terminal escape sequences. This method is called automatically
+    # by RawLine::Editor#bind().
+    #
+    def update
+      @keys.each_value do |k|
+        l = k.length
+        if  l > 1 then
+          @escape_sequences << k unless @escape_sequences.include? k
+        end
+      end
+    end
+
+    def term_info
+      @term_info ||= TermInfo.new(ENV["TERM"], $stdout)
+    end
+
+  end
+
+
+end

data/lib/rawline/terminal/vt220_terminal.rb

@@ -0,0 +1,66 @@
+#!usr/bin/env ruby
+
+#
+#  vt220_terminal.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+
+module RawLine
+
+  #
+  # This class is used to define all the most common character codes and
+  # escape sequences used on *nix systems.
+  #
+  class VT220Terminal < Terminal
+
+    def initialize
+      super
+      @escape_codes = [?\e.ord]
+      @keys.merge!(
+        {
+          :up_arrow => [?\e.ord, ?[.ord, ?A.ord],
+          :down_arrow => [?\e.ord, ?[.ord, ?B.ord],
+          :right_arrow => [?\e.ord, ?[.ord, ?C.ord],
+          :left_arrow => [?\e.ord, ?[.ord, ?D.ord],
+          :insert => [?\e.ord, ?[, ?2.ord, ?~.ord],
+          :delete => [?\e.ord, ?[, ?3.ord, ?~.ord],
+          :backspace => [?\C-?.ord],
+          :enter => (HighLine::SystemExtensions::CHARACTER_MODE == 'termios' ? [?\n.ord] : [?\r.ord]),
+
+          :ctrl_alt_a => [?\e.ord, ?\C-a.ord],
+          :ctrl_alt_b => [?\e.ord, ?\C-b.ord],
+          :ctrl_alt_c => [?\e.ord, ?\C-c.ord],
+          :ctrl_alt_d => [?\e.ord, ?\C-d.ord],
+          :ctrl_alt_e => [?\e.ord, ?\C-e.ord],
+          :ctrl_alt_f => [?\e.ord, ?\C-f.ord],
+          :ctrl_alt_g => [?\e.ord, ?\C-g.ord],
+          :ctrl_alt_h => [?\e.ord, ?\C-h.ord],
+          :ctrl_alt_i => [?\e.ord, ?\C-i.ord],
+          :ctrl_alt_j => [?\e.ord, ?\C-j.ord],
+          :ctrl_alt_k => [?\e.ord, ?\C-k.ord],
+          :ctrl_alt_l => [?\e.ord, ?\C-l.ord],
+          :ctrl_alt_m => [?\e.ord, ?\C-m.ord],
+          :ctrl_alt_n => [?\e.ord, ?\C-n.ord],
+          :ctrl_alt_o => [?\e.ord, ?\C-o.ord],
+          :ctrl_alt_p => [?\e.ord, ?\C-p.ord],
+          :ctrl_alt_q => [?\e.ord, ?\C-q.ord],
+          :ctrl_alt_r => [?\e.ord, ?\C-r.ord],
+          :ctrl_alt_s => [?\e.ord, ?\C-s.ord],
+          :ctrl_alt_t => [?\e.ord, ?\C-t.ord],
+          :ctrl_alt_u => [?\e.ord, ?\C-u.ord],
+          :ctrl_alt_v => [?\e.ord, ?\C-v.ord],
+          :ctrl_alt_w => [?\e.ord, ?\C-w.ord],
+          :ctrl_alt_x => [?\e.ord, ?\C-x.ord],
+          :ctrl_alt_y => [?\e.ord, ?\C-y.ord],
+          :ctrl_alt_z => [?\e.ord, ?\C-z.ord]
+        })
+    end
+
+  end
+
+
+end

data/lib/rawline/terminal/windows_terminal.rb

@@ -0,0 +1,66 @@
+#!usr/bin/env ruby
+
+#
+#  windows_terminal.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+
+module RawLine
+
+  #
+  # This class is used to define all the most common character codes and
+  # escape sequences used on Windows systems.
+  #
+  class WindowsTerminal < Terminal
+
+    def initialize
+      super
+      @escape_codes = [0, 27, 224]
+      @keys.merge!(
+        {
+          :left_arrow => [224, 75],
+          :right_arrow => [224, 77],
+          :up_arrow => [224, 72],
+          :down_arrow => [224, 80],
+          :insert => [224, 82],
+          :delete => [224, 83],
+          :backspace => [8],
+          :enter => [13],
+
+          :ctrl_alt_a => [0, 30],
+          :ctrl_alt_b => [0, 48],
+          :ctrl_alt_c => [0, 46],
+          :ctrl_alt_d => [0, 32],
+          :ctrl_alt_e => [0, 63],
+          :ctrl_alt_f => [0, 33],
+          :ctrl_alt_g => [0, 34],
+          :ctrl_alt_h => [0, 35],
+          :ctrl_alt_i => [0, 23],
+          :ctrl_alt_j => [0, 36],
+          :ctrl_alt_k => [0, 37],
+          :ctrl_alt_l => [0, 26],
+          :ctrl_alt_m => [0, 32],
+          :ctrl_alt_n => [0, 31],
+          :ctrl_alt_o => [0, 24],
+          :ctrl_alt_p => [0, 25],
+          :ctrl_alt_q => [0, 16],
+          :ctrl_alt_r => [0, 19],
+          :ctrl_alt_s => [0, 31],
+          :ctrl_alt_t => [0, 20],
+          :ctrl_alt_u => [0, 22],
+          :ctrl_alt_v => [0, 47],
+          :ctrl_alt_w => [0, 17],
+          :ctrl_alt_x => [0, 45],
+          :ctrl_alt_y => [0, 21],
+          :ctrl_alt_z => [0, 44]
+        })
+    end
+
+  end
+
+
+end

data/spec/editor_spec.rb

@@ -0,0 +1,260 @@
+#!/usr/bin/env ruby
+
+require 'highline/system_extensions'
+
+module HighLine::SystemExtensions
+  # Override Windows' character reading so it's not tied to STDIN.
+  def get_character( input = STDIN )
+    (RUBY_VERSION.gsub(/1\./, '').to_f >= 8.7) ? input.getbyte : input.getc
+  end
+end
+
+require 'stringio'
+require_relative "../lib/rawline.rb"
+
+describe RawLine::Editor do
+
+  before :each do
+    @output = StringIO.new
+    @input = StringIO.new
+    @editor = RawLine::Editor.new(@input, @output)
+  end
+
+  it "reads raw characters from @input" do
+    @input << "test #1"
+    @input.rewind
+     @editor.read
+    expect(@editor.line.text).to eq("test #1")
+    expect(@output.string).to eq("test #1\n")
+  end
+
+  it "can bind keys to code blocks" do
+    @editor.bind(:ctrl_w) { @editor.write "test #2a" }
+    @editor.bind(?\C-q) { "test #2b" }
+    @editor.bind(21) { "test #2c" }
+    @editor.bind([22]) { "test #2d" }
+    @editor.terminal.escape_codes = [] # remove any existing escape codes
+    expect {@editor.bind({:test => [?\e.ord, ?t.ord, ?e.ord, ?s.ord, ?t.ord]}) { "test #2e" }}.to raise_error(RawLine::BindingException)
+    @editor.terminal.escape_codes << ?\e.ord
+    expect {@editor.bind({:test => "\etest"}) { "test #2e" }}.to_not raise_error
+    expect {@editor.bind("\etest2") { "test #2f" }}.to_not raise_error
+    @input << ?\C-w.chr
+    @input.rewind
+     @editor.read
+    expect(@editor.line.text).to eq("test #2a")
+    @editor.char = [?\C-q.ord]
+    expect(@editor.press_key).to eq("test #2b")
+    @editor.char = [?\C-u.ord]
+    expect(@editor.press_key).to eq("test #2c")
+    @editor.char = [?\C-v.ord]
+    expect(@editor.press_key).to eq("test #2d")
+    @editor.char = [?\e.ord, ?t.ord, ?e.ord, ?s.ord, ?t.ord]
+    expect(@editor.press_key).to eq("test #2e")
+    @editor.char = [?\e.ord, ?t.ord, ?e.ord, ?s.ord, ?t.ord, ?2.ord]
+    expect(@editor.press_key).to eq("test #2f")
+  end
+
+  it "keeps track of the cursor position" do
+    @input << "test #4"
+    @input.rewind
+    @editor.read
+    expect(@editor.line.position).to eq(7)
+    3.times { @editor.move_left }
+    expect(@editor.line.position).to eq(4)
+    2.times { @editor.move_right }
+    expect(@editor.line.position).to eq(6)
+  end
+
+  describe "keeping track of the cursor position across terminal lines (e.g. multi-line editing)" do
+    let(:terminal_width){ 3 }
+    let(:terminal_height){ 7 }
+    let(:output){ @output.rewind ; @output.read }
+    let(:arrow_key_left_ansi){ "\e[D" }
+    let(:arrow_key_right_ansi){ "\e[C" }
+
+    before do
+      allow(@editor).to receive(:terminal_size).and_return [terminal_width, terminal_height]
+    end
+
+    context "and the cursor position is at the first character of the second line" do
+      before do
+        @input << "123"
+      end
+
+      it "is at the first character of a second line" do
+        @input.rewind
+        @editor.read
+        expect(@editor.line.position).to eq(3)
+      end
+
+      describe "moving left from the first position of the second line" do
+        before do
+          @input << arrow_key_left_ansi
+          @input.rewind
+          @editor.read
+        end
+
+        it "sends the escape sequences moving the cursor to the end of the previous line" do
+          expected_ansi_sequence = "\e[A\e[#{terminal_width}C"
+          expect(output).to eq("123#{expected_ansi_sequence}\n")
+        end
+
+        it "correctly sets the line's position" do
+          expect(@editor.line.position).to eq(2)
+        end
+      end
+
+      describe "moving right from the first position of the second line" do
+        before do
+          @input << arrow_key_right_ansi
+          @input.rewind
+          @editor.read
+        end
+
+        it "doesn't send any escape sequences" do
+          expected_ansi_sequence = "\e[A\e[#{terminal_width}C"
+          expect(output).to_not include("\e")
+        end
+
+        it "doesn't move the cursor when it's at the end of the input" do
+          expect(@editor.line.position).to eq(3)
+        end
+      end
+
+      describe "moving left to the previous line then right to the next line" do
+        before do
+          # this is the one that moves us to the previous line
+          @input << arrow_key_left_ansi
+
+          # these are for fun to show that we don't generate unnecessary
+          # escape sequences
+          @input << arrow_key_left_ansi
+          @input << arrow_key_left_ansi
+          @input << arrow_key_left_ansi
+
+          # now let's move right again
+          @input << arrow_key_right_ansi
+          @input << arrow_key_right_ansi
+          @input << arrow_key_right_ansi
+
+          # this is the one that puts us on the next line
+          @input << arrow_key_right_ansi
+
+          @input.rewind
+          @editor.read
+        end
+
+        it "sends the the escape sequence for moving to the previous line just once" do
+          expected_ansi_sequence = "\e[A\e[#{terminal_width}C"
+          expect(output.scan(expected_ansi_sequence).flatten.length).to eq(1)
+        end
+
+        it "sends the the escape sequence for moving to the next line just once" do
+          expected_ansi_sequence = "\e[B\e[#{terminal_width}D"
+          expect(output.scan(expected_ansi_sequence).flatten.length).to eq(1)
+        end
+
+        it "correctly sets the line's position" do
+          expect(@editor.line.position).to eq(3)
+        end
+      end
+    end
+  end
+
+  it "can delete characters" do
+    @input << "test #5"
+    @input.rewind
+    @editor.read
+    3.times { @editor.move_left }
+    4.times { @editor.delete_left_character }
+    3.times { @editor.delete_character }
+    expect(@editor.line.text).to eq("")
+    expect(@editor.line.position).to eq(0)
+  end
+
+  it "can clear the whole line" do
+    @input << "test #5"
+    @input.rewind
+    @editor.read
+    @editor.clear_line
+    expect(@editor.line.text).to eq("")
+    expect(@editor.line.position).to eq(0)
+  end
+
+  it "supports undo and redo" do
+    @input << "test #6"
+    @input.rewind
+    @editor.read
+    3.times { @editor.delete_left_character }
+    2.times { @editor.undo }
+    expect(@editor.line.text).to eq("test #")
+    2.times { @editor.redo }
+    expect(@editor.line.text).to eq("test")
+  end
+
+  it "supports history" do
+    @input << "test #7a"
+    @input.rewind
+    @editor.read "", true
+    @editor.newline
+    @input << "test #7b"
+    @input.pos = 8
+    @editor.read "", true
+    @editor.newline
+    @input << "test #7c"
+    @input.pos = 16
+    @editor.read "", true
+    @editor.newline
+    @input << "test #7d"
+    @input.pos = 24
+    @editor.read "", true
+    @editor.newline
+    @editor.history_back
+    expect(@editor.line.text).to eq("test #7c")
+    10.times { @editor.history_back }
+    expect(@editor.line.text).to eq("test #7a")
+    2.times { @editor.history_forward }
+    expect(@editor.line.text).to eq("test #7c")
+  end
+
+  it "can overwrite lines" do
+    @input << "test #8a"
+    @input.rewind
+    @editor.read
+    @editor.overwrite_line("test #8b", 2)
+    expect(@editor.line.text).to eq("test #8b")
+    expect(@editor.line.position).to eq(2)
+  end
+
+  it "can complete words" do
+    @editor.completion_append_string = "\t"
+    @editor.bind(:tab) { @editor.complete }
+    @editor.completion_proc = lambda do |word|
+      if word then
+         ['select', 'update', 'delete', 'debug', 'destroy'].find_all  { |e| e.match(/^#{Regexp.escape(word)}/) }
+      end
+    end
+    @input << "test #9 de" << ?\t.chr << ?\t.chr
+    @input.rewind
+    @editor.read
+    expect(@editor.line.text).to eq("test #9 delete\t")
+  end
+
+  it "supports INSERT and REPLACE modes" do
+    @input << "test 0"
+    @editor.terminal.keys[:left_arrow].each { |k| @input << k.chr }
+    @input << "#1"
+    @input.rewind
+    @editor.read
+    expect(@editor.line.text).to eq("test #10")
+    @editor.toggle_mode
+    @input << "test 0"
+    @editor.terminal.keys[:left_arrow].each { |k| @input << k.chr }
+    @input << "#1"
+    @input.rewind
+    @editor.read
+    expect(@editor.line.text).to eq("test #1test #1")
+  end
+
+
+end