yap-rawline 0.1.1 → 0.2.0

data/lib/rawline/event_loop.rb

@@ -5,6 +5,7 @@ module RawLine
     def initialize(registry:)
       @registry = registry
       @events = []
+      @counter = 0
     end
 
     # event looks like:
@@ -12,46 +13,79 @@ module RawLine
     #  * source
     #  * target
     #  * payload
-    def add_event(**event)
+    def add_event(**event, &blk)
+      unless event.has_key?(:_event_callback)
+        event[:_event_callback] = blk if blk
+      end
+
+      unless event.has_key?(:_event_id)
+        @counter += 1
+        event[:_event_id] = @counter
+      end
+
       # if the last event is the same as the incoming then do there is no
       # need to add it again. For example, rendering events that already
       # back can be squashed into a single event.
       if @events.last != event
         @events << event
+        event[:_event_id]
+      else
+        @events.last[:_event_id]
       end
     end
 
-    def recur(event:nil, interval_in_ms:, &blk)
-      if block_given?
-        # TODO: implement
-      elsif event
-        add_event event.merge(recur: { interval_in_ms: interval_in_ms, recur_at: recur_at(interval_in_ms) })
-      else
-        raise "Must pass in a block or an event."
-      end
+    def clear(event_id)
+      @events = @events.reject { |event| event[:_event_id] == event_id }
     end
 
-    def start
-      loop do
-        event = @events.shift
-        if event
-          recur = event[:recur]
-          if recur
-            if current_time_in_ms >= recur[:recur_at]
-              dispatch_event(event)
-              interval_in_ms = recur[:interval_in_ms]
-              add_event event.merge(recur: { interval_in_ms: interval_in_ms, recur_at: recur_at(interval_in_ms) } )
-            else
-              # put it back on the queue
-              add_event event
-              dispatch_event(default_event)
-            end
+    def reset
+      @events.clear
+      @counter = 0
+    end
+
+    def once(interval_in_ms:, **event, &blk)
+      add_event event.merge(once: { run_at: recur_at(interval_in_ms) }), &blk
+    end
+
+    def recur(interval_in_ms:, **event, &blk)
+      add_event event.merge(recur: { interval_in_ms: interval_in_ms, recur_at: recur_at(interval_in_ms) }), &blk
+    end
+
+    def tick
+      event = @events.shift
+      if event
+        recur = event[:recur]
+        once = event[:once]
+        if recur
+          if current_time_in_ms >= recur[:recur_at]
+            dispatch_event(event)
+            interval_in_ms = recur[:interval_in_ms]
+            add_event event.merge(recur: { interval_in_ms: interval_in_ms, recur_at: recur_at(interval_in_ms) } )
           else
+            # put it back on the queue
+            @events << event
+            dispatch_event(default_event)
+          end
+        elsif once
+          if current_time_in_ms >= once[:run_at]
             dispatch_event(event)
+          else
+            # put it back on the queue
+            @events << event
+            # add_event event
+            dispatch_event(default_event)
           end
         else
-          dispatch_event(default_event)
+          dispatch_event(event)
         end
+      else
+        dispatch_event(default_event)
+      end
+    end
+
+    def start
+      loop do
+        tick
       end
     end
 
@@ -62,7 +96,7 @@ module RawLine
     end
 
     def default_event
-      { name: 'default', source: self }
+      { name: 'default', source: self, _event_id: -1 }
     end
 
     def recur_at(interval_in_ms)
@@ -73,6 +107,9 @@ module RawLine
       @registry.subscribers_for_event(event[:name]).each do |subscriber|
         subscriber.call(event)
       end
+
+      callback = event[:_event_callback]
+      callback.call(event) if callback
     end
   end
 end

data/lib/rawline/non_blocking_input.rb

@@ -0,0 +1,34 @@
+module RawLine
+  class NonBlockingInput
+    DEFAULT_WAIT_TIMEOUT_IN_SECONDS = 0.01
+
+    attr_accessor :wait_timeout_in_seconds
+
+    def initialize(input)
+      @input = input
+      restore_default_timeout
+    end
+
+    def restore_default_timeout
+      @wait_timeout_in_seconds = DEFAULT_WAIT_TIMEOUT_IN_SECONDS
+    end
+
+    def read
+      bytes = []
+      begin
+        file_descriptor_flags = @input.fcntl(Fcntl::F_GETFL, 0)
+        loop do
+          string = @input.read_nonblock(4096)
+          bytes.concat string.bytes
+        end
+      rescue IO::WaitReadable
+        # reset flags so O_NONBLOCK is turned off on the file descriptor
+        # if it was turned on during the read_nonblock above
+        retry if IO.select([@input], [], [], @wait_timeout_in_seconds)
+
+        @input.fcntl(Fcntl::F_SETFL, file_descriptor_flags)
+      end
+      bytes
+    end
+  end
+end

data/lib/rawline/renderer.rb

@@ -0,0 +1,29 @@
+module RawLine
+  class Renderer
+    def initialize(dom:, output:, width:, height:)
+      @dom = dom
+      @output = output
+      @renderer = TerminalLayout::TerminalRenderer.new(output: output)
+      @render_tree = TerminalLayout::RenderTree.new(
+        dom,
+        parent: nil,
+        style: { width: width, height: height },
+        renderer: @renderer
+      )
+    end
+
+    def render(reset: false)
+      @render_tree.layout
+      @renderer.render(@render_tree, reset: reset)
+    end
+
+    def render_cursor(input_box)
+      @renderer.render_cursor(input_box)
+    end
+
+    def update_dimensions(width:, height:)
+      @render_tree.width = width
+      @render_tree.height = height
+    end
+  end
+end

data/lib/rawline/terminal.rb

@@ -3,6 +3,7 @@
 require 'terminfo'
 require 'io/console'
 require 'ostruct'
+require 'termios'
 
 #
 #  terminal.rb
@@ -23,22 +24,25 @@ module RawLine
   # RawLine::Editor.
   #
   class Terminal
-
     include HighLine::SystemExtensions
 
-    attr_accessor :escape_codes
+    attr_accessor :escape_codes, :input, :output
     attr_reader :keys, :escape_sequences
 
     #
     # Create an instance of RawLine::Terminal.
     #
-    def initialize
+    def initialize(input, output)
+      @input = input
+      @output = output
+      @snapshotted_tty_attrs = []
       @keys =
         {
         :tab => [?\t.ord],
         :return => [?\r.ord],
         :newline => [?\n.ord],
         :escape => [?\e.ord],
+        :space => [32],
 
         :ctrl_a => [?\C-a.ord],
         :ctrl_b => [?\C-b.ord],
@@ -74,6 +78,39 @@ module RawLine
 
     CursorPosition = Struct.new(:column, :row)
 
+    def raw!
+      @input.raw!
+    end
+
+    def cooked!
+      @input.cooked!
+    end
+
+    def pseudo_cooked!
+      old_tty_attrs = Termios.tcgetattr(@input)
+      new_tty_attrs = old_tty_attrs.dup
+
+
+      new_tty_attrs.cflag |= Termios::BRKINT | Termios::ISTRIP | Termios::ICRNL | Termios::IXON
+
+      new_tty_attrs.iflag |= Termios::ICRNL | Termios::IGNBRK
+
+      new_tty_attrs.oflag |= Termios::OPOST
+
+      new_tty_attrs.lflag &= ~Termios::ECHONL
+      new_tty_attrs.lflag |= Termios::ECHO | Termios::ECHOE | Termios::ECHOK | Termios::ICANON | Termios::ISIG | Termios::IEXTEN
+
+      Termios::tcsetattr(@input, Termios::TCSANOW, new_tty_attrs)
+    end
+
+    def snapshot_tty_attrs
+      @snapshotted_tty_attrs << Termios.tcgetattr(@input)
+    end
+
+    def restore_tty_attrs
+      Termios::tcsetattr(@input, Termios::TCSANOW, @snapshotted_tty_attrs.pop)
+    end
+
     def cursor_position
       res = ''
       $stdin.raw do |stdin|
@@ -131,6 +168,12 @@ module RawLine
       n.times { term_info.control "cud1" }
     end
 
+    def puts(*args)
+      @output.cooked do
+        @output.puts(*args)
+      end
+    end
+
     def preserve_cursor(&blk)
       term_info.control "sc" # store cursor position
       blk.call
@@ -138,6 +181,18 @@ module RawLine
       term_info.control "rc" # restore cursor position
     end
 
+    def width
+      terminal_size[0]
+    end
+
+    def height
+      terminal_size[1]
+    end
+
+    def cursor_position
+      cursor_position
+    end
+
     #
     # Update the terminal escape sequences. This method is called automatically
     # by RawLine::Editor#bind().

data/lib/rawline/terminal/vt220_terminal.rb

@@ -17,8 +17,8 @@ module RawLine
   #
   class VT220Terminal < Terminal
 
-    def initialize
-      super
+    def initialize(*args)
+      super(*args)
       @escape_codes = [?\e.ord]
       @keys.merge!(
         {

data/spec/editor_spec.rb

@@ -12,20 +12,62 @@ end
 require 'stringio'
 require_relative "../lib/rawline.rb"
 
-describe RawLine::Editor do
+class DummyInput < RawLine::NonBlockingInput
+  def initialize
+    @input = StringIO.new
+  end
 
-  before :each do
-    @output = StringIO.new
+  def read
+    @input.read.bytes
+  end
+
+  def clear
     @input = StringIO.new
-    @editor = RawLine::Editor.new(@input, @output)
   end
 
-  it "reads raw characters from @input" do
-    @input << "test #1"
+  def <<(bytes)
+    @input << bytes
+  end
+
+  def rewind
     @input.rewind
-     @editor.read
+  end
+end
+
+describe RawLine::Editor do
+  let(:dom) { RawLine::DomTree.new }
+  let(:renderer) do
+    instance_double(RawLine::Renderer,
+      render_cursor: nil,
+      render: nil
+    )
+  end
+  let(:input) { DummyInput.new }
+  let(:terminal) do
+    output = double("IO", cooked: nil)
+    RawLine::VT220Terminal.new(input, output)
+  end
+
+  before do
+    @editor = RawLine::Editor.new(
+      dom: dom,
+      input: input,
+      renderer: renderer,
+      terminal: terminal
+    ) do |editor|
+      editor.prompt = ">"
+    end
+    @editor.on_read_line do |event|
+      line = event[:payload][:line]
+    end
+  end
+
+  it "reads raw characters from @input" do
+    input << "test #1"
+    input.rewind
+    @editor.event_loop.tick
     expect(@editor.line.text).to eq("test #1")
-    expect(@output.string).to eq("test #1\n")
+    expect(@editor.dom.input_box.content).to eq("test #1")
   end
 
   it "can bind keys to code blocks" do
@@ -38,9 +80,9 @@ describe RawLine::Editor do
     @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
+    input << ?\C-w
+    input.rewind
+    @editor.event_loop.tick
     expect(@editor.line.text).to eq("test #2a")
     @editor.char = [?\C-q.ord]
     expect(@editor.press_key).to eq("test #2b")
@@ -55,9 +97,9 @@ describe RawLine::Editor do
   end
 
   it "keeps track of the cursor position" do
-    @input << "test #4"
-    @input.rewind
-    @editor.read
+    input << "test #4"
+    input.rewind
+    @editor.event_loop.tick
     expect(@editor.line.position).to eq(7)
     3.times { @editor.move_left }
     expect(@editor.line.position).to eq(4)
@@ -68,103 +110,110 @@ describe RawLine::Editor do
   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]
+      allow(@editor.terminal).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"
+        input << "123"
+        input.rewind
       end
 
       it "is at the first character of a second line" do
-        @input.rewind
-        @editor.read
+        @editor.event_loop.tick
         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 "moves the line and cursor position to left by 1 character" do
+          @editor.event_loop.tick
+          expect(@editor.line.position).to eq(3)
+          expect(@editor.input_box.cursor_position.x).to eq(3)
 
-        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
+          input.clear
+          input << arrow_key_left_ansi
+          input.rewind
+
+          @editor.event_loop.reset
+          @editor.event_loop.tick
 
-        it "correctly sets the line's position" do
           expect(@editor.line.position).to eq(2)
+          expect(@editor.input_box.cursor_position.x).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 "doesnt move the line and cursor position" do
+          @editor.event_loop.tick
+          expect(@editor.line.position).to eq(3)
+          expect(@editor.input_box.cursor_position.x).to eq(3)
 
-        it "doesn't send any escape sequences" do
-          expected_ansi_sequence = "\e[A\e[#{terminal_width}C"
-          expect(output).to_not include("\e")
-        end
+          input.clear
+          input << arrow_key_right_ansi
+          input.rewind
+
+          @editor.event_loop.reset
+          @editor.event_loop.tick
 
-        it "doesn't move the cursor when it's at the end of the input" do
           expect(@editor.line.position).to eq(3)
+          expect(@editor.input_box.cursor_position.x).to eq(3)
         end
       end
 
       describe "moving left to the previous line then right to the next line" do
         before do
+          @editor.event_loop.tick
+
           # this is the one that moves us to the previous line
-          @input << arrow_key_left_ansi
+          input.clear
+          input << arrow_key_left_ansi
+          input.rewind
+          @editor.event_loop.reset
+          @editor.event_loop.tick
 
           # 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
+          input.clear
+          input << arrow_key_left_ansi
+          input << arrow_key_left_ansi
+          input << arrow_key_left_ansi
+          input.rewind
+          @editor.event_loop.reset
+          @editor.event_loop.tick
 
           # now let's move right again
-          @input << arrow_key_right_ansi
-          @input << arrow_key_right_ansi
-          @input << arrow_key_right_ansi
+          input.clear
+          input << arrow_key_right_ansi
+          input << arrow_key_right_ansi
+          input << arrow_key_right_ansi
+          input.rewind
+          @editor.event_loop.reset
+          @editor.event_loop.tick
 
           # 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)
+          input.clear
+          input << arrow_key_right_ansi
+          input.rewind
+          @editor.event_loop.reset
+          @editor.event_loop.tick
         end
 
-        it "correctly sets the line's position" do
+        it "correctly sets the line and cursor position" do
           expect(@editor.line.position).to eq(3)
+          expect(@editor.input_box.cursor_position.x).to eq(3)
         end
       end
     end
   end
 
   it "can delete characters" do
-    @input << "test #5"
-    @input.rewind
-    @editor.read
+    input << "test #5"
+    input.rewind
+    @editor.event_loop.tick
     3.times { @editor.move_left }
     4.times { @editor.delete_left_character }
     3.times { @editor.delete_character }
@@ -173,18 +222,18 @@ describe RawLine::Editor do
   end
 
   it "can clear the whole line" do
-    @input << "test #5"
-    @input.rewind
-    @editor.read
+    input << "test #5"
+    input.rewind
+    @editor.event_loop.tick
     @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
+    input << "test #6"
+    input.rewind
+    @editor.event_loop.tick
     3.times { @editor.delete_left_character }
     2.times { @editor.undo }
     expect(@editor.line.text).to eq("test #")
@@ -192,9 +241,9 @@ describe RawLine::Editor do
     expect(@editor.line.text).to eq("test")
   end
 
-  it "supports history" do
-    @input << "test #7a"
-    @input.rewind
+  xit "supports history" do
+    input << "test #7a"
+    input.rewind
     @editor.read "", true
     @editor.newline
     @input << "test #7b"
@@ -218,15 +267,15 @@ describe RawLine::Editor do
   end
 
   it "can overwrite lines" do
-    @input << "test #8a"
-    @input.rewind
-    @editor.read
+    input << "test #8a"
+    input.rewind
+    @editor.event_loop.tick
     @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
+  xit "can complete words" do
     @editor.completion_append_string = "\t"
     @editor.bind(:tab) { @editor.complete }
     @editor.completion_proc = lambda do |word|
@@ -234,27 +283,33 @@ describe RawLine::Editor do
          ['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
+    input << "test #9 de" << ?\t.chr << ?\t.chr
+    input.rewind
+    @editor.event_loop.tick
     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
+  xit "supports INSERT and REPLACE modes" do
+    input << "test 0"
+    @editor.terminal.keys[:left_arrow].each { |k| input << k.chr }
+    input << "#1"
+    input.rewind
+    @editor.event_loop.tick
     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
+    input << "test 0"
+    @editor.terminal.keys[:left_arrow].each { |k| input << k.chr }
+    input << "#1"
+    input.rewind
+    @editor.event_loop.tick
     expect(@editor.line.text).to eq("test #1test #1")
   end
 
-
+  describe '#puts' do
+    it 'puts to the terminal, then re-renders' do
+      expect(terminal).to receive(:puts).with("A", "B", "C").ordered
+      expect(renderer).to receive(:render).with(reset: true)
+      @editor.puts("A", "B", "C")
+    end
+  end
 end