vedeu 0.6.59 → 0.6.60

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5813addb77c651976f42073bc53aab1b4af606a
-  data.tar.gz: 3cb787a6bb92c95ef9a883eced3c6452afdccf8b
+  metadata.gz: 686a2b4fb8270f973081dc3c7d108cdb49e6449a
+  data.tar.gz: 4ad07b62d0523da5bcfa758b53d1602b12396bc5
 SHA512:
-  metadata.gz: b55242a13ddc309b76455ccb9938abf0f2c517f448b82a43f885cede2e82616c2b6c9419f80f48b7283f4fcda220cc3d5eb1b31b74e719ebb751d1d9f7ed4849
-  data.tar.gz: e8005cd4ff555b0a51cfbbba53401cf2040291382c6b87f7687c1553c97a9c24f6eb6f308c2d4df106c5e2a5b728b7c36e93599bdc61eb3cded59be34e77dfc2
+  metadata.gz: 019242a5c896bf72c9e396f389ec4e185b461d9839087ae68f208a17c62307137aece08f65174ba3d4aa68f4d90233b327138dcaec1de35f858fa916ac58f43c
+  data.tar.gz: f1489ca293258577eef48e095e8cea55cc22502d14c0a2df0f3fd281b0b200348cb6dd9486a92a845c68638d766514a7771d01dc63d1a6e4fe0b15c3abfa2ef0

data/lib/vedeu/borders/all.rb

@@ -37,6 +37,5 @@ require 'vedeu/borders/title'
 require 'vedeu/borders/caption'
 require 'vedeu/borders/border'
 require 'vedeu/borders/dsl'
-require 'vedeu/borders/null'
 require 'vedeu/borders/refresh'
 require 'vedeu/borders/repository'

data/lib/vedeu/borders/repository.rb

@@ -9,7 +9,7 @@ module Vedeu
 
       singleton_class.send(:alias_method, :borders, :repository)
 
-      null Vedeu::Borders::Null
+      null Vedeu::Borders::Border, enabled: false
       real Vedeu::Borders::Border
 
     end # Repository

data/lib/vedeu/editor/all.rb

@@ -8,7 +8,6 @@ module Vedeu
 
 end # Vedeu
 
-require 'vedeu/editor/capture'
 require 'vedeu/editor/cropper'
 require 'vedeu/editor/delete'
 require 'vedeu/editor/editor'

data/lib/vedeu/input/capture.rb

@@ -2,27 +2,31 @@ module Vedeu
 
   module Input
 
-    # Captures input from the user via {Vedeu::Terminal#input} and
+    # Captures input from the user terminal via 'getch' and
     # translates special characters into symbols.
     #
     class Capture
 
+      ESCAPE_KEY_CODE = 27 # \e
+
+      extend Forwardable
+
+      def_delegators Vedeu::Terminal::Mode,
+                     :cooked_mode?,
+                     :fake_mode?,
+                     :raw_mode?
+
       # Instantiate Vedeu::Input::Input and capture keypress(es).
       #
-      # @param (see #initialize)
       # @return (see #read)
-      def self.read(reader)
-        new(reader).read
+      def self.read
+        new.read
       end
 
       # Returns a new instance of Vedeu::Input::Input.
       #
-      # @param reader [IO] An object that responds to `#read`.
-      #   Typically, this is Vedeu::Terminal.
       # @return [Vedeu::Input::Input]
-      def initialize(reader)
-        @reader = reader
-      end
+      def initialize; end
 
       # Triggers various events dependent on the terminal mode.
       #
@@ -42,68 +46,97 @@ module Vedeu
       #
       # @return [Array|String|Symbol]
       def read
-        if click?(keypress)
-          Vedeu.trigger(:_mouse_event_, keypress)
+        Vedeu.log(type: :input, message: 'Waiting for user input...'.freeze)
 
-        elsif reader.raw_mode?
+        if raw_mode?
           Vedeu.trigger(:_keypress_, keypress)
 
-        elsif reader.fake_mode?
-          name      = Vedeu.focus
-          interface = Vedeu.interfaces.by_name(name)
-          key       = keypress
+        elsif fake_mode?
+          @key ||= keypress
+
+          if click?(@key)
+            Vedeu.trigger(:_mouse_event_, @key)
 
-          if Vedeu::Input::Mapper.registered?(key, name)
-            Vedeu.trigger(:_keypress_, key, name)
+          elsif Vedeu::Input::Mapper.registered?(@key, name)
+            Vedeu.trigger(:_keypress_, @key, name)
 
           elsif interface.editable?
-            Vedeu.trigger(:_editor_, key)
+            Vedeu.trigger(:_editor_, @key)
+
+          elsif @key.nil?
+            nil
 
           else
-            Vedeu.trigger(:key, key)
+            Vedeu.trigger(:key, @key)
 
           end
-        else
+
+        elsif cooked_mode?
           Vedeu.trigger(:_command_, command)
 
         end
       end
 
-      protected
+      private
 
-      # @!attribute [r] reader
-      # @return [IO]
-      attr_reader :reader
+      # Returns the translated (when possible) keypress(es).
+      #
+      # @return [String|Symbol]
+      def keypress
+        Vedeu::Input::Translator.translate(input)
+      end
 
-      private
+      # Takes input from the user via the keyboard. Accepts special
+      # keys like the F-Keys etc, by capturing the entire sequence.
+      #
+      # @return [String]
+      def input
+        keys = console.getch
+
+        if keys.ord == ESCAPE_KEY_CODE
+          keys << console.read_nonblock(4) rescue nil
+          keys << console.read_nonblock(3) rescue nil
+          keys << console.read_nonblock(2) rescue nil
+        end
+
+        return Vedeu::Input::Mouse.click(keys) if click?(keys)
+
+        keys
+      end
 
       # Returns a boolean indicating whether a mouse click was
       # received.
       #
-      # @param key [String]
+      # @param key [NilClass|String|Symbol|Vedeu::Cursors::Cursor]
       # @return [Boolean]
-      def click?(key)
-        return false if key.is_a?(Symbol)
+      def click?(input)
+        return false if input.nil? || input.is_a?(Symbol)
 
-        key.is_a?(Vedeu::Cursors::Cursor) || key.start_with?("\e[M")
+        input.is_a?(Vedeu::Cursors::Cursor) || input.start_with?("\e[M")
       end
 
-      # Returns the translated (when possible) keypress(es).
-      #
-      # @return [String|Symbol]
-      def keypress
-        key = input
-
-        @keypress ||= Vedeu::Input::Translator.translate(key)
+      # @return [IO]
+      def console
+        @console ||= Vedeu::Terminal.console
       end
 
-      # Returns the input from the terminal.
+      # Takes input from the user via the keyboard. Accepts special
+      # keys like the F-Keys etc, by capturing the entire sequence.
       #
       # @return [String]
-      def input
-        @input ||= reader.read
+      def command
+        console.gets.chomp
+      end
+
+      # @return [String|Symbol]
+      def name
+        Vedeu.focus
+      end
+
+      # @return [Vedeu::Interfaces::Interface]
+      def interface
+        Vedeu.interfaces.by_name(name)
       end
-      alias_method :command, :input
 
     end # Input
 

data/lib/vedeu/input/mouse.rb

@@ -29,6 +29,8 @@ module Vedeu
         Vedeu.log(type:    :input,
                   message: "Mouse pressed: '#{button}' (x: #{x}, y: #{y})")
 
+        Vedeu.trigger(:_mouse_event_, input)
+
         if left_click?
           Vedeu.trigger(:_cursor_reposition_, Vedeu.focus, y, x)
 

data/lib/vedeu/repositories/repository.rb

@@ -62,8 +62,10 @@ module Vedeu
       #
       # @param name [String|Symbol] The name of the stored model.
       # @return [void]
-      def by_name(name = Vedeu.focus)
-        return find(name) if present?(name) && registered?(name)
+      def by_name(name = nil)
+        name = present?(name) ? name : Vedeu.focus
+
+        return find(name) if registered?(name)
 
         attrs = if null_attributes.any?
                   null_attributes.merge!(name: name)

data/lib/vedeu/runtime/application.rb

@@ -102,7 +102,7 @@ module Vedeu
       # @return [void]
       def main_sequence
         if configuration.interactive?
-          Vedeu::Input::Capture.read(Terminal)
+          Vedeu::Input::Capture.read
 
         else
           Vedeu.trigger(:_standalone_)

data/lib/vedeu/terminal/terminal.rb

@@ -29,23 +29,6 @@ module Vedeu
       restore_screen
     end
 
-    # Takes input from the user via the keyboard. Accepts special keys
-    # like the F-Keys etc, by capturing the entire sequence.
-    #
-    # @return [String]
-    def input
-      Vedeu.log(type: :input, message: 'Waiting for user input...'.freeze)
-
-      if raw_mode? || fake_mode?
-        Vedeu::Editor::Capture.read(console)
-
-      else
-        console.gets.chomp
-
-      end
-    end
-    alias_method :read, :input
-
     # Prints the streams to the screen and returns the streams.
     #
     # @param streams [String|Array]

data/lib/vedeu/version.rb

@@ -1,6 +1,6 @@
 module Vedeu
 
   # The current version of Vedeu.
-  VERSION = '0.6.59'.freeze
+  VERSION = '0.6.60'.freeze
 
 end

data/test/lib/vedeu/groups/refresh_test.rb

@@ -49,7 +49,7 @@ module Vedeu
           context 'when no interfaces/views have been registered' do
             before { Vedeu::Models::Focus.reset }
 
-            it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
+            it { proc { subject }.must_raise(Vedeu::Error::Fatal) }
           end
         end
 

data/test/lib/vedeu/input/capture_test.rb

@@ -6,132 +6,251 @@ module Vedeu
 
     describe Capture do
 
-      let(:reader)    { Vedeu::Terminal }
-      let(:keypress)  { 'a' }
       let(:described) { Vedeu::Input::Capture }
-      let(:instance)  { described.new(reader) }
-      let(:raw_mode)  { true }
+      let(:instance)  { described.new }
 
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }
-        it { instance.instance_variable_get('@reader').must_equal(reader) }
+      end
+
+      describe '#read' do
+        it { instance.must_respond_to(:read) }
       end
 
       describe '.read' do
+        let(:is_cooked_mode) { false }
+        let(:is_fake_mode)   { false }
+        let(:is_raw_mode)    { false }
+        let(:keypress)       {}
+        let(:_name)          { 'Vedeu::Input::Capture' }
+        let(:interface)      {
+          Vedeu::Interfaces::Interface.new(editable: editable,
+                                           name:     _name)
+        }
+        let(:editable)       { false }
+
         before do
-          reader.stubs(:raw_mode?).returns(raw_mode)
-          reader.stubs(:fake_mode?).returns(fake_mode)
-          Vedeu.stubs(:trigger).returns([false])
+          Vedeu::Terminal::Mode.stubs(:cooked_mode?).returns(is_cooked_mode)
+          Vedeu::Terminal::Mode.stubs(:fake_mode?).returns(is_fake_mode)
+          Vedeu::Terminal::Mode.stubs(:raw_mode?).returns(is_raw_mode)
+          Vedeu.stubs(:focus).returns(_name)
         end
 
-        subject { described.read(reader) }
+        subject { described.read }
 
-        context 'when in cooked mode' do
-          let(:raw_mode)  { false }
-          let(:fake_mode) { false }
-          let(:command)   { 'help' }
+        it 'appends "Waiting for user input..." to the log' do
+          Vedeu.expects(:log)
+          subject
+        end
 
-          before { reader.stubs(:read).returns(command) }
+        context 'when the terminal mode is :fake' do
+          let(:is_fake_mode) { true }
+          let(:registered)   { false }
 
-          it 'triggers an event with the command' do
-            Vedeu.expects(:trigger).with(:_command_, command)
-            subject
+          before do
+            Vedeu::Terminal.console.stubs(:getch).returns(keypress)
+            Vedeu::Input::Mapper.stubs(:registered?).with(translated, _name).returns(registered)
+            Vedeu.interfaces.stubs(:by_name).returns(interface)
           end
-        end
 
-        context 'when in fake mode' do
-          let(:raw_mode)  { false }
-          let(:fake_mode) { true }
-          let(:keypress)  { 'b' }
+          context 'when the keypress is an escape sequence' do
+            context 'when the key is :shift_f5 (read_nonblock(7))' do
+              let(:keypress)   { "\e[15;2~" }
+              let(:translated) { :shift_f5 }
 
-          before { reader.stubs(:read).returns(keypress) }
+              context 'when the key is registered with a keymap' do
+                let(:registered) { true }
 
-          context 'when an interface or view has been registered' do
-            let(:interface_name) { :fake_interface }
-            let(:interface)      {
-              Vedeu::Interfaces::Interface.new(name: interface_name, editable: editable)
-            }
-            let(:editable)       { false }
-            let(:registered)     { false }
+                it {
+                  Vedeu::Input::Mapper.expects(:registered?).with(translated, _name)
+                  subject
+                }
+
+                it {
+                  Vedeu.expects(:trigger).with(:_keypress_, translated, 'Vedeu::Input::Capture')
+                  subject
+                }
+              end
 
-            before do
-              Vedeu.stubs(:focus).returns(interface_name)
-              Vedeu.interfaces.stubs(:by_name).with(interface_name).returns(interface)
-              Vedeu::Input::Mapper.expects(:registered?).with(keypress, interface_name).returns(registered)
+              context 'when the key is not registered with a keymap' do
+                context 'when the interface is editable' do
+                  let(:editable) { true }
+
+                  it {
+                    Vedeu.expects(:trigger).with(:_editor_, :shift_f5)
+                    subject
+                  }
+                end
+
+                context 'when the interface is not editable' do
+                  it {
+                    Vedeu.expects(:trigger).with(:key, :shift_f5)
+                    subject
+                  }
+                end
+              end
             end
 
-            context 'when the keypress is registered with the keymap' do
-              let(:registered) { true }
+            context 'when the key is really a mouse click (read_nonblock(6))' do
+              let(:keypress)   { "\e[M`6E" }
+              let(:translated) {}
 
-              it 'triggers an event with the keypress' do
-                Vedeu.expects(:trigger).with(:_keypress_, keypress, interface_name)
+              it {
+                Vedeu.expects(:trigger).with(:_cursor_up_, _name)
+                Vedeu.expects(:trigger).with(:_mouse_event_, "\e[M`6E")
                 subject
-              end
+              }
             end
 
-            context 'when the keypress is not registered with the keymap' do
-              let(:registered) { false }
+            context 'when the key is :f6 key (read_nonblock(5))' do
+              let(:keypress)   { "\e[17~" }
+              let(:translated) { :f6 }
 
-              context 'when the interface or view is editable' do
-                let(:editable) { true }
+              it {
+                Vedeu.expects(:trigger).with(:key, translated)
+                subject
+              }
+            end
 
-                it 'triggers an event with the keypress' do
-                  Vedeu.expects(:trigger).with(:_editor_, keypress)
-                  subject
-                end
-              end
+            context 'when the key is :delete (read_nonblock(4))' do
+              let(:keypress) { "\e[3~" }
+              let(:translated) { :delete }
 
-              context 'when the interface or view is not editable' do
-                let(:editable) { false }
+              it {
+                Vedeu.expects(:trigger).with(:key, translated)
+                subject
+              }
+            end
 
-                it 'triggers an event with the keypress' do
-                  Vedeu.expects(:trigger).with(:key, keypress)
-                  subject
-                end
-              end
+            context 'when the key is :up (read_nonblock(3))' do
+              let(:keypress) { "\e[A" }
+              let(:translated) { :up }
+
+              it {
+                Vedeu.expects(:trigger).with(:key, translated)
+                subject
+              }
+            end
+
+            context 'when the key is :escape (read_nonblock(1))' do
+              let(:keypress) { "\e" }
+              let(:translated) { :escape }
+
+              it {
+                Vedeu.expects(:trigger).with(:key, translated)
+                subject
+              }
             end
           end
 
-          # context 'when no interfaces or views have been registered' do
-          #   before {
-          #     Vedeu.focus.reset
-          #     Vedeu.interfaces.reset
-          #   }
+          context 'when the keypress is not an escape sequence' do
+            let(:keypress)   { 'r' }
+            let(:translated) { 'r' }
 
-          #   it { proc { subject }.must_raise(Vedeu::Error::Fatal) }
-          # end
+            it {
+              Vedeu.expects(:trigger).with(:key, keypress)
+              subject
+            }
+          end
         end
 
-        context 'when in raw mode' do
-          let(:raw_mode)  { true }
-          let(:fake_mode) { false }
-          let(:keypress)  { 'a' }
+        context 'when the terminal mode is :raw' do
+          let(:is_raw_mode) { true }
 
-          before { reader.stubs(:read).returns(keypress) }
+          before do
+            Vedeu::Terminal.console.stubs(:getch).returns(keypress)
+          end
 
-          context 'when the key is not special' do
-            it 'triggers an event with the keypress' do
-              Vedeu.expects(:trigger).with(:_keypress_, keypress)
-              subject
+          context 'when the keypress is an escape sequence' do
+            context 'when the key is :shift_f5 (read_nonblock(7))' do
+              let(:keypress) { "\e[15;2~" }
+
+              it {
+                Vedeu.expects(:trigger).with(:_keypress_, :shift_f5)
+                subject
+              }
             end
-          end
 
-          context 'when the key is special' do
-            let(:keypress) { "\e[A" }
+            context 'when the key is really a mouse click (read_nonblock(6))' do
+              let(:keypress) { "\e[M`6E" }
 
-            it 'triggers an event with the keypress' do
-              Vedeu.expects(:trigger).with(:_keypress_, :up)
-              subject
+              it {
+                Vedeu.expects(:trigger).with(:_cursor_up_, _name)
+                Vedeu.expects(:trigger).with(:_mouse_event_, "\e[M`6E")
+                Vedeu.expects(:trigger).with(:_keypress_, nil)
+                subject
+              }
             end
 
-            context 'when the key is an F key' do
+            context 'when the key is :f6 key (read_nonblock(5))' do
               let(:keypress) { "\e[17~" }
 
-              it 'triggers an event with the keypress' do
+              it {
                 Vedeu.expects(:trigger).with(:_keypress_, :f6)
                 subject
-              end
+              }
+            end
+
+            context 'when the key is :delete (read_nonblock(4))' do
+              let(:keypress) { "\e[3~" }
+
+              it {
+                Vedeu.expects(:trigger).with(:_keypress_, :delete)
+                subject
+              }
             end
+
+            context 'when the key is :up (read_nonblock(3))' do
+              let(:keypress) { "\e[A" }
+
+              it {
+                Vedeu.expects(:trigger).with(:_keypress_, :up)
+                subject
+              }
+            end
+
+            context 'when the key is :escape (read_nonblock(1))' do
+              let(:keypress) { "\e" }
+
+              it {
+                Vedeu.expects(:trigger).with(:_keypress_, :escape)
+                subject
+              }
+            end
+          end
+
+          context 'when the keypress is not an escape sequence' do
+            let(:keypress)    { 'r' }
+
+            it {
+              Vedeu.expects(:trigger).with(:_keypress_, keypress)
+              subject
+            }
+          end
+        end
+
+        context 'when the terminal mode is :cooked' do
+          let(:command)        { "help\n" }
+          let(:is_cooked_mode) { true }
+
+          before do
+            Vedeu::Terminal.console.stubs(:gets).returns(command)
+          end
+
+          context 'when the input is a mouse click' do
+            let(:command) { "\e[M`6E" }
+
+            it {
+              Vedeu.expects(:trigger).with(:_command_, command)
+              subject
+            }
+          end
+
+          context 'when the input is not a mouse click' do
+            it {
+              Vedeu.expects(:trigger).with(:_command_, 'help')
+              subject
+            }
           end
         end
       end

data/test/lib/vedeu/input/mouse_test.rb

@@ -25,6 +25,7 @@ module Vedeu
           let(:input) { "\e[M ,%" }
 
           it {
+            Vedeu.expects(:trigger).with(:_mouse_event_, input)
             Vedeu.expects(:trigger).with(:_cursor_reposition_, Vedeu.focus, 5, 12)
             subject
           }
@@ -34,6 +35,7 @@ module Vedeu
           let(:input) { "\e[M`6E" }
 
           it {
+            Vedeu.expects(:trigger).with(:_mouse_event_, input)
             Vedeu.expects(:trigger).with(:_cursor_up_, Vedeu.focus)
             subject
           }
@@ -43,6 +45,7 @@ module Vedeu
           let(:input) { "\e[MaN5" }
 
           it {
+            Vedeu.expects(:trigger).with(:_mouse_event_, input)
             Vedeu.expects(:trigger).with(:_cursor_down_, Vedeu.focus)
             subject
           }
@@ -52,6 +55,7 @@ module Vedeu
           let(:input) { "\e[Mb0(" }
 
           it {
+            Vedeu.expects(:trigger).with(:_mouse_event_, input)
             subject.must_equal("\e[93m[input]  \e[39m\e[33mVedeu does not " \
                                "support mouse button '66' yet.\e[39m")
           }

data/test/lib/vedeu/output/viewport_test.rb

@@ -22,9 +22,15 @@ module Vedeu
       }
       let(:visible)   { true }
       let(:interface) {
-        Vedeu::Interfaces::Interface.new(style: nil, visible: visible)
+        Vedeu::Interfaces::Interface.new(name:    'lithium',
+                                         style:   nil,
+                                         visible: visible)
+      }
+      let(:geometry)  {
+        Vedeu::Geometry::Geometry.new(name:   'lithium',
+                                      height: 3,
+                                      width:  3)
       }
-      let(:geometry)  { Vedeu::Geometry::Geometry.new(height: 3, width: 3) }
       let(:ready)     { true }
 
       before do

data/test/lib/vedeu/terminal/terminal_test.rb

@@ -44,40 +44,6 @@ module Vedeu
       end
     end
 
-    describe '.input' do
-      before { Vedeu.stubs(:log) }
-
-      subject { Vedeu::Terminal.input }
-
-      it { described.must_respond_to(:read) }
-
-      context 'when the terminal is in cooked mode' do
-        let(:mode)  { :cooked }
-        let(:input) { "Some input\r\n" }
-
-        before do
-          Vedeu::Terminal.stubs(:mode).returns(mode)
-          console.stubs(:gets).returns(input)
-        end
-
-        it { subject.must_equal('Some input') }
-      end
-
-      # context 'when the terminal is in raw mode' do
-      #   let(:mode)  { :raw }
-      #   let(:input) { "\e[A" }
-
-      #   before do
-      #     Vedeu::Terminal.stubs(:mode).returns(mode)
-      #     # console.stubs(:getch).returns(input)
-      #     # input.stubs(:ord).returns(27)
-      #     # console.stubs(:read_nonblock)
-      #   end
-
-      #   it { subject.must_be_instance_of(Symbol) }
-      # end
-    end
-
     describe '.output' do
       before { IO.console.stubs(:print) }
 

data/test/support/examples/material_colours_app.rb

@@ -270,14 +270,12 @@ class VedeuMaterialColoursApp
     zindex(0)
   end
 
-
-
   Vedeu.keymap('_global_') do
-    key(:up)    { Vedeu.trigger(:_cursor_up_)    }
-    key(:right) { Vedeu.trigger(:_cursor_right_) }
-    key(:down)  { Vedeu.trigger(:_cursor_down_)  }
-    key(:left)  { Vedeu.trigger(:_cursor_left_)  }
-    key(:home)  { Vedeu.trigger(:_cursor_top_) }
+    key(:up)    { Vedeu.trigger(:_cursor_up_)     }
+    key(:right) { Vedeu.trigger(:_cursor_right_)  }
+    key(:down)  { Vedeu.trigger(:_cursor_down_)   }
+    key(:left)  { Vedeu.trigger(:_cursor_left_)   }
+    key(:home)  { Vedeu.trigger(:_cursor_top_)    }
     key(:end)   { Vedeu.trigger(:_cursor_bottom_) }
 
     key(:insert) do
@@ -373,7 +371,7 @@ class VedeuMaterialColoursApp
     end
 
     view 'keys_interface' do
-      # cursor false
+      cursor false
       line {
         stream {
           left "\u2190 \u2193 \u2191 \u2192",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vedeu
 version: !ruby/object:Gem::Version
-  version: 0.6.59
+  version: 0.6.60
 platform: ruby
 authors:
 - Gavin Laking
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-17 00:00:00.000000000 Z
+date: 2015-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
@@ -332,7 +332,6 @@ files:
 - lib/vedeu/borders/border.rb
 - lib/vedeu/borders/caption.rb
 - lib/vedeu/borders/dsl.rb
-- lib/vedeu/borders/null.rb
 - lib/vedeu/borders/refresh.rb
 - lib/vedeu/borders/repository.rb
 - lib/vedeu/borders/title.rb
@@ -387,7 +386,6 @@ files:
 - lib/vedeu/dsl/use.rb
 - lib/vedeu/dsl/view.rb
 - lib/vedeu/editor/all.rb
-- lib/vedeu/editor/capture.rb
 - lib/vedeu/editor/cropper.rb
 - lib/vedeu/editor/cursor.rb
 - lib/vedeu/editor/delete.rb
@@ -537,7 +535,6 @@ files:
 - test/lib/vedeu/borders/border_test.rb
 - test/lib/vedeu/borders/caption_test.rb
 - test/lib/vedeu/borders/dsl_test.rb
-- test/lib/vedeu/borders/null_test.rb
 - test/lib/vedeu/borders/refresh_test.rb
 - test/lib/vedeu/borders/repository_test.rb
 - test/lib/vedeu/borders/title_test.rb
@@ -576,7 +573,6 @@ files:
 - test/lib/vedeu/dsl/text_test.rb
 - test/lib/vedeu/dsl/use_test.rb
 - test/lib/vedeu/dsl/view_test.rb
-- test/lib/vedeu/editor/capture_test.rb
 - test/lib/vedeu/editor/cropper_test.rb
 - test/lib/vedeu/editor/cursor_test.rb
 - test/lib/vedeu/editor/delete_test.rb
@@ -750,7 +746,6 @@ test_files:
 - test/lib/vedeu/borders/border_test.rb
 - test/lib/vedeu/borders/caption_test.rb
 - test/lib/vedeu/borders/dsl_test.rb
-- test/lib/vedeu/borders/null_test.rb
 - test/lib/vedeu/borders/refresh_test.rb
 - test/lib/vedeu/borders/repository_test.rb
 - test/lib/vedeu/borders/title_test.rb
@@ -789,7 +784,6 @@ test_files:
 - test/lib/vedeu/dsl/text_test.rb
 - test/lib/vedeu/dsl/use_test.rb
 - test/lib/vedeu/dsl/view_test.rb
-- test/lib/vedeu/editor/capture_test.rb
 - test/lib/vedeu/editor/cropper_test.rb
 - test/lib/vedeu/editor/cursor_test.rb
 - test/lib/vedeu/editor/delete_test.rb

data/lib/vedeu/borders/null.rb

@@ -1,63 +0,0 @@
-module Vedeu
-
-  module Borders
-
-    # Provides a non-existent Vedeu::Borders::Border that acts like
-    # the real thing, but does nothing.
-    #
-    # @api private
-    #
-    class Null
-
-      extend Forwardable
-
-      def_delegators :geometry,
-                     :bordered_width,
-                     :bordered_height,
-                     :bx,
-                     :bxn,
-                     :by,
-                     :byn,
-                     :x,
-                     :xn,
-                     :y,
-                     :yn
-
-      # @!attribute [r] name
-      # @return [String|Symbol|NilClass]
-      attr_reader :name
-
-      # Returns a new instance of Vedeu::Borders::Null.
-      #
-      # @param attributes [Hash<Symbol => void>]
-      # @option attributes name [String|Symbol|NilClass]
-      # @return [Vedeu::Borders::Null]
-      def initialize(attributes = {})
-        @attributes = attributes
-        @name       = @attributes[:name]
-      end
-
-      # @return [Boolean]
-      def enabled?
-        false
-      end
-
-      # @return [Array]
-      def render
-        []
-      end
-
-      private
-
-      # Returns the geometry for the interface.
-      #
-      # @return (see Vedeu::Geometry::Repository#by_name)
-      def geometry
-        @geometry ||= Vedeu.geometries.by_name(name)
-      end
-
-    end # Null
-
-  end # Borders
-
-end # Vedeu

data/lib/vedeu/editor/capture.rb

@@ -1,66 +0,0 @@
-module Vedeu
-
-  module Editor
-
-    # Capture input from the terminal via 'getch'.
-    #
-    class Capture
-
-      ESCAPE_KEY_CODE = 27 # \e
-
-      # @param console [IO]
-      # @return [String|Symbol]
-      def self.read(console)
-        new(console).read
-      end
-
-      # Returns a new instance of Vedeu::Editor::Capture.
-      #
-      # @param console [IO]
-      # @return [Vedeu::Editor::Capture]
-      def initialize(console)
-        @console = console
-      end
-
-      # @return [String|Symbol]
-      def read
-        Vedeu::Input::Translator.translate(keys)
-      end
-
-      private
-
-      # @return [String]
-      def keys
-        keys = console.getch
-
-        if keys.ord == ESCAPE_KEY_CODE
-          keys << console.read_nonblock(5) rescue nil
-          keys << console.read_nonblock(4) rescue nil
-          keys << console.read_nonblock(3) rescue nil
-          keys << console.read_nonblock(2) rescue nil
-        end
-
-        return Vedeu::Input::Mouse.click(keys) if click?(keys)
-
-        keys
-      end
-
-      # Returns a boolean indicating whether a mouse click was
-      # received.
-      #
-      # @param keys [String]
-      # @return [Boolean]
-      def click?(keys)
-        keys.start_with?("\e[M")
-      end
-
-      # @return [IO]
-      def console
-        @console || Vedeu::Terminal.console
-      end
-
-    end # Capture
-
-  end # Editor
-
-end # Vedeu

data/test/lib/vedeu/borders/null_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  module Borders
-
-    describe Null do
-
-      let(:described) { Vedeu::Borders::Null }
-      let(:instance)  { described.new(attributes) }
-      let(:attributes){
-        {
-          name: _name
-        }
-      }
-      let(:_name)     { 'null_border' }
-      let(:geometry)  {
-        Vedeu::Geometry::Geometry.new(name: _name, x: 4, y: 6, xn: 10, yn: 12)
-      }
-
-      before { Vedeu.geometries.stubs(:by_name).returns(geometry) }
-
-      describe '#initialize' do
-        it { instance.must_be_instance_of(described) }
-        it {
-          instance.instance_variable_get('@attributes').must_equal(attributes)
-        }
-        it { instance.instance_variable_get('@name').must_equal(_name) }
-      end
-
-      describe 'accessors' do
-        it { instance.must_respond_to(:name) }
-      end
-
-      describe '#enabled' do
-        subject { instance.enabled? }
-
-        it { subject.must_equal(false) }
-      end
-
-      describe '#render' do
-        subject { instance.render }
-
-        it { subject.must_be_instance_of(Array) }
-        it { subject.must_equal([]) }
-      end
-
-    end # Null
-
-  end # Borders
-
-end # Vedeu

data/test/lib/vedeu/editor/capture_test.rb

@@ -1,63 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  module Editor
-
-    describe Capture do
-
-      let(:described) { Vedeu::Editor::Capture }
-      let(:instance)  { described.new(console) }
-      let(:console)   { mock }
-
-      describe '#initialize' do
-        it { instance.must_be_instance_of(described) }
-        it { instance.instance_variable_get('@console').must_equal(console) }
-      end
-
-      describe '.read' do
-        subject { described.read(console) }
-
-        before do
-          Vedeu::Terminal.stubs(:console).returns(console)
-          console.stubs(:getch).returns(keys)
-        end
-
-        context 'when nothing is given' do
-          let(:keys) { nil }
-        end
-
-        context 'when a single keypress is given' do
-          let(:keys) { 'a' }
-
-          it { subject.must_equal('a') }
-        end
-
-        context 'when a ctrl+keypress is given' do
-          let(:keys) { "\u0001" }
-
-          it { subject.must_equal(:ctrl_a) }
-        end
-
-        context 'when a shift+keypress is given' do
-          let(:keys) { 'A' }
-
-          it { subject.must_equal('A') }
-        end
-
-        context 'when a alt+keypress is given' do
-        end
-
-        context 'when a super+keypress is given' do
-        end
-      end
-
-      describe '#read' do
-        it { instance.must_respond_to(:read) }
-      end
-
-    end # Capture
-
-  end # Editor
-
-end # Vedeu