vedeu 0.5.13 → 0.6.0

data/test/lib/vedeu/input/editor/document_test.rb

@@ -0,0 +1,190 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Editor
+
+    describe Document do
+
+      let(:described) { Vedeu::Editor::Document }
+      let(:instance)   { described.new(attributes) }
+      let(:attributes) {
+        {
+          data: data,
+          name: _name,
+        }
+      }
+      let(:data)   {
+        "Hydrogen\n"  \
+        "Helium\n"    \
+        "Lithium\n"
+      }
+      let(:_name)  { 'Vedeu::Editor::Document' }
+
+      before { Vedeu::Direct.stubs(:write) }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@data').must_equal(data) }
+        it { instance.instance_variable_get('@name').must_equal(_name) }
+        it {
+          instance.instance_variable_get('@repository').
+            must_equal(Vedeu.documents)
+        }
+      end
+
+      describe 'accessors' do
+        it { instance.must_respond_to(:attributes) }
+        it { instance.must_respond_to(:data) }
+        it { instance.must_respond_to(:data=) }
+        it { instance.must_respond_to(:name) }
+        it { instance.must_respond_to(:name=) }
+      end
+
+      describe '#clear' do
+        subject { instance.clear }
+
+      end
+
+      describe '#delete_character' do
+        let(:y) { 0 }
+        let(:x) { 0 }
+
+        subject { instance.delete_character }
+
+        it { subject.must_be_instance_of(described) }
+
+        # it { skip }
+      end
+
+      describe '#delete_line' do
+        let(:y) { 0 }
+
+        subject { instance.delete_line }
+
+        it { subject.must_be_instance_of(described) }
+
+        # it { skip }
+      end
+
+      describe '#insert_character' do
+        let(:character) { 'a' }
+
+        subject { instance.insert_character(character) }
+
+        it { subject.must_be_instance_of(described) }
+
+        # it { skip }
+
+        context 'when the character is a Symbol' do
+          let(:character) { :a }
+
+          it { subject.must_equal(instance) }
+        end
+      end
+
+      describe '#insert_line' do
+        let(:y) { 2 }
+
+        subject { instance.insert_line }
+
+        it { subject.must_be_instance_of(described) }
+
+        # it { skip }
+      end
+
+      describe '#line' do
+        subject { instance.line }
+
+        context 'when the line is empty' do
+          let(:data) {}
+
+          it { subject.must_equal(Vedeu::Editor::Line.new('')) }
+        end
+
+        context 'when the line is not empty' do
+          it { subject.must_equal(Vedeu::Editor::Line.new('Hydrogen')) }
+        end
+
+        # context 'when y is set' do
+        #   let(:y) { 2 }
+
+        #   it { subject.must_equal(Vedeu::Editor::Line.new('Lithium')) }
+        # end
+      end
+
+      describe '#lines' do
+        subject { instance.lines }
+
+        context 'when the data is empty' do
+          let(:data) {}
+          let(:expected) {
+            Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new])
+          }
+
+          it { subject.must_equal(expected) }
+        end
+
+        context 'when the data is not empty' do
+          let(:expected) {
+            Vedeu::Editor::Lines.new([
+              Vedeu::Editor::Line.new('Hydrogen'),
+              Vedeu::Editor::Line.new('Helium'),
+              Vedeu::Editor::Line.new('Lithium'),
+            ])
+          }
+
+          it { subject.must_equal(expected) }
+        end
+      end
+
+      describe '#render' do
+        let(:data) {
+          Vedeu::Editor::Lines.new([
+            Vedeu::Editor::Line.new('A'),
+            Vedeu::Editor::Line.new('B'),
+            Vedeu::Editor::Line.new('C'),
+          ])
+        }
+        let(:output) { "\e[1;1HA\e[2;1HB\e[3;1HC\e[1;1H\e[?25h" }
+
+        before { Vedeu::Direct.stubs(:write) }
+
+        subject { instance.render }
+
+        it {
+          Vedeu::Direct.expects(:write).with(value: output, x: 1, y: 1)
+          subject
+        }
+      end
+
+      describe '#reset!' do
+        subject { instance.reset! }
+
+        it { subject.must_be_instance_of(described) }
+      end
+
+      describe '#retrieve' do
+        subject { instance.retrieve }
+
+        it { subject.must_be_instance_of(String) }
+
+        it { subject.must_equal("Hydrogen\nHelium\nLithium") }
+      end
+
+      describe '#store' do
+        subject { instance.store }
+
+        it { subject.must_be_instance_of(described) }
+
+        it {
+          instance.expects(:render)
+          subject
+        }
+      end
+
+    end # Editor
+
+  end # Editor
+
+end # Vedeu

data/test/lib/vedeu/input/editor/documents_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Editor
+
+    describe Documents do
+
+      let(:described) { Vedeu::Editor::Documents }
+
+      it { described.must_respond_to(:documents) }
+
+    end # Documents
+
+  end # Editor
+
+end # Vedeu

data/test/lib/vedeu/input/editor/editor_test.rb

@@ -0,0 +1,170 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Editor
+
+    describe Editor do
+
+      let(:described) { Vedeu::Editor::Editor }
+      let(:instance)  {
+        described.new(input: input, name: _name)
+      }
+      let(:input)     {}
+      let(:_name)     { 'Vedeu::Editor::Editor' }
+      let(:document)  { Vedeu::Editor::Document.new(data: data, name: _name) }
+      let(:data)      {
+        "Hydrogen\n"  \
+        "Helium\n"    \
+        "Lithium\n"
+      }
+
+      before do
+        Vedeu.documents.stubs(:by_name).returns(document)
+        # document.stubs(:clear)
+        # document.stubs(:delete_character)
+        # document.stubs(:delete_line)
+        # document.stubs(:down)
+        # document.stubs(:left)
+        # document.stubs(:right)
+        # document.stubs(:insert_character)
+        # document.stubs(:insert_line)
+        # document.stubs(:render)
+        # document.stubs(:reset!)
+        # document.stubs(:retrieve)
+        # document.stubs(:up)
+      end
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@input').must_equal(input) }
+        it { instance.instance_variable_get('@name').must_equal(_name) }
+      end
+
+      describe '.keypress' do
+        before { Vedeu::Terminal.stubs(:output) }
+
+        subject { described.keypress(input: input, name: _name) }
+
+        context 'when no name is given' do
+          let(:document) {}
+
+          it 'returns the input instead of sending to the document' do
+            subject.must_equal(input)
+          end
+        end
+
+        context 'when a name is given' do
+          context 'when the input is :backspace' do
+            let(:input) { :backspace }
+
+            it {
+              document.expects(:delete_character)
+              subject
+            }
+          end
+
+          context 'when the input is :ctrl_c' do
+            let(:input) { :ctrl_c }
+
+            it {
+              Vedeu.expects(:trigger).with(:_exit_)
+              subject
+            }
+          end
+
+          context 'when the input is :down' do
+            let(:input) { :down }
+
+            it {
+              document.expects(:down)
+              subject
+            }
+          end
+
+          context 'when the input is :enter' do
+            let(:input) { :enter }
+
+            it {
+              document.expects(:insert_line)
+              subject
+            }
+          end
+
+          context 'when the input is :escape' do
+            let(:input) { :escape }
+
+            it {
+              Vedeu.expects(:trigger).with(:_mode_switch_)
+              subject
+            }
+          end
+
+          context 'when the input is :left' do
+            let(:input) { :left }
+
+            it {
+              document.expects(:left)
+              subject
+            }
+          end
+
+          context 'when the input is :right' do
+            let(:input) { :right }
+
+            it {
+              document.expects(:right)
+              subject
+            }
+          end
+
+          context 'when the input is :tab' do
+            let(:input) { :tab }
+            let(:data)  { mock(:empty? => false) }
+
+            # it {
+            #   document.expects(:retrieve).returns(data)
+            #   document.expects(:reset!)
+            #   document.expects(:clear)
+            #   Vedeu.expects(:trigger).with(:_command_, data)
+            #   subject
+            # }
+          end
+
+          context 'when the input is :up' do
+            let(:input) { :up }
+
+            it {
+              document.expects(:up)
+              subject
+            }
+          end
+
+          context 'when the input is something else' do
+            context 'when the input is a symbol' do
+              let(:input) { :ctrl_p }
+
+              it { subject.must_be_instance_of(String) }
+            end
+
+            context 'when the input is not a symbol' do
+              let(:input) { 'a' }
+
+              it {
+                document.expects(:insert_character).with(input)
+                subject
+              }
+            end
+          end
+        end
+      end
+
+      describe '#keypress' do
+        it { instance.must_respond_to(:keypress) }
+      end
+
+    end # Editor
+
+  end # Editor
+
+end # Vedeu

data/test/lib/vedeu/input/editor/line_test.rb

@@ -0,0 +1,333 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Editor
+
+    describe Line do
+
+      let(:described) { Vedeu::Editor::Line }
+      let(:instance)  { described.new(line) }
+      let(:line)      { 'Some text...' }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@line').must_equal(line) }
+
+        context 'when a line is not given' do
+          let(:line) {}
+
+          it { instance.instance_variable_get('@line').must_equal('') }
+        end
+      end
+
+      describe 'accessors' do
+        it { instance.must_respond_to(:line) }
+        it { instance.must_respond_to(:line=) }
+      end
+
+      describe '.coerce' do
+        let(:_value) {}
+
+        subject { described.coerce(_value) }
+
+        it { subject.must_be_instance_of(Vedeu::Editor::Line) }
+
+        context 'when the value is already a Vedeu::Editor::Line object' do
+          let(:_value) { Vedeu::Editor::Line.new(line) }
+
+          it { subject.must_equal(_value) }
+          it { subject.line.must_equal(line) }
+        end
+
+        context 'when the value is an empty String' do
+          let(:_value) { '' }
+
+          it { subject.line.must_equal('') }
+        end
+
+        context 'when the value is an String' do
+          let(:_value) { line }
+
+          it { subject.line.must_equal(line) }
+        end
+      end
+
+      describe '#[]' do
+        subject { instance.[](index) }
+
+        context 'when index is a Fixnum' do
+          let(:index)    { 2 }
+
+          it { subject.must_equal('m') }
+        end
+
+        context 'when index is a Range' do
+          let(:index)    { (3..6) }
+
+          it { subject.must_equal('e te') }
+        end
+      end
+
+      describe '#character' do
+        let(:index) { 5 }
+
+        subject { instance.character(index) }
+
+        it { subject.must_be_instance_of(String) }
+
+        context 'when the line is empty' do
+          let(:line) { '' }
+
+          context 'and an index is not given' do
+            let(:index) {}
+
+            it { subject.must_equal('') }
+          end
+        end
+
+        context 'when the line is not empty' do
+          context 'when an index is not given' do
+            let(:index) {}
+
+            it { subject.must_equal('.') }
+          end
+
+          context 'when a negative index is given' do
+            let(:index) { -4 }
+
+            it { subject.must_equal('S') }
+          end
+
+          context 'when an index is given' do
+            it { subject.must_equal('t') }
+          end
+
+          context 'when an index of the last character of the line is given' do
+            let(:index) { 11 }
+
+            it { subject.must_equal('.') }
+          end
+
+          context 'when an index greater than the line length is given' do
+            let(:index) { 20 }
+
+            it { subject.must_equal('.') }
+          end
+        end
+      end
+
+      describe '#delete_character' do
+        let(:index) { 5 }
+
+        subject { instance.delete_character(index) }
+
+        it { subject.must_be_instance_of(Vedeu::Editor::Line) }
+
+        context 'when the line is empty' do
+          let(:line) { '' }
+
+          it { subject.line.must_equal('') }
+
+          context 'and an index is not given' do
+            let(:index) {}
+
+            it { subject.line.must_equal('') }
+          end
+        end
+
+        context 'when the line is not empty' do
+          context 'when an index is not given' do
+            let(:index) {}
+
+            it { subject.line.must_equal('Some text..') }
+          end
+
+          context 'when a negative index is given' do
+            let(:index) { -4 }
+
+            it { subject.line.must_equal('Some text...') }
+          end
+
+          context 'when an index is given' do
+            it { subject.line.must_equal('Some ext...') }
+          end
+
+          context 'when an index of the last character of the line is given' do
+            let(:index) { 11 }
+
+            it { subject.line.must_equal('Some text..') }
+          end
+
+          context 'when an index greater than the line length is given' do
+            let(:index) { 20 }
+
+            it { subject.line.must_equal('Some text..') }
+          end
+        end
+      end
+
+      describe '#empty?' do
+        subject { instance.empty? }
+
+        context 'when the line is empty' do
+          let(:line) {}
+
+          it { subject.must_equal(true) }
+        end
+
+        context 'when the line is not empty' do
+          it { subject.must_equal(false) }
+        end
+      end
+
+      describe '#eql?' do
+        let(:other) { instance }
+
+        subject { instance.eql?(other) }
+
+        it { subject.must_equal(true) }
+
+        context 'when different to other' do
+          let(:other) { described.new('Other text...') }
+
+          it { subject.must_equal(false) }
+        end
+      end
+
+      describe '#insert_character' do
+        let(:character) { 'a' }
+        let(:index)     { 5 }
+
+        subject { instance.insert_character(character, index) }
+
+        it { subject.must_be_instance_of(Vedeu::Editor::Line) }
+
+        context 'when the line is empty' do
+          let(:line) {}
+
+          it { subject.line.must_equal('a') }
+
+          context 'and an index is not given' do
+            let(:index) {}
+
+            it { subject.line.must_equal('a') }
+          end
+
+          context 'and a negative index is given' do
+            let(:index) { -4 }
+
+            it { subject.line.must_equal('a') }
+          end
+
+          context 'and an index is given' do
+            it { subject.line.must_equal('a') }
+          end
+
+          context 'and an index of the last character of the line is given' do
+            let(:index) { 0 }
+
+            it { subject.line.must_equal('a') }
+          end
+
+          context 'and an index greater than the line length is given' do
+            let(:index) { 20 }
+
+            it { subject.line.must_equal('a') }
+          end
+        end
+
+        context 'when the line is not empty' do
+          context 'and an index is not given' do
+            let(:index) {}
+
+            it { subject.line.must_equal('Some text...a') }
+          end
+
+          context 'and a negative index is given' do
+            let(:index) { -4 }
+
+            it { subject.line.must_equal('aSome text...') }
+          end
+
+          context 'and an index is given' do
+            it { subject.line.must_equal('Some atext...') }
+          end
+
+          context 'and an index of the last character of the line is given' do
+            let(:index) { 12 }
+
+            it { subject.line.must_equal('Some text...a') }
+          end
+
+          context 'and an index greater than the line length is given' do
+            let(:index) { 20 }
+
+            it { subject.line.must_equal('Some text...a') }
+          end
+        end
+      end
+
+      describe '#size' do
+        subject { instance.size }
+
+        context 'when the line is empty' do
+          let(:line) {}
+
+          it { subject.must_equal(0) }
+        end
+
+        context 'when the line is not empty' do
+          it { subject.must_equal(12) }
+        end
+      end
+
+      describe '#to_chars' do
+        subject { instance.to_chars }
+
+        context 'when the line is empty' do
+          let(:line) {}
+
+          it { subject.must_equal([]) }
+        end
+
+        context 'when the line is not empty' do
+          let(:expected) {
+            [
+              Vedeu::Views::Char.new(value: 'S'),
+              Vedeu::Views::Char.new(value: 'o'),
+              Vedeu::Views::Char.new(value: 'm'),
+              Vedeu::Views::Char.new(value: 'e'),
+              Vedeu::Views::Char.new(value: ' '),
+              Vedeu::Views::Char.new(value: 't'),
+              Vedeu::Views::Char.new(value: 'e'),
+              Vedeu::Views::Char.new(value: 'x'),
+              Vedeu::Views::Char.new(value: 't'),
+              Vedeu::Views::Char.new(value: '.'),
+              Vedeu::Views::Char.new(value: '.'),
+              Vedeu::Views::Char.new(value: '.'),
+            ]
+          }
+          it { subject.must_equal(expected) }
+        end
+      end
+
+      describe '#to_s' do
+        subject { instance.to_s }
+
+        context 'when the line is empty' do
+          let(:line) {}
+
+          it { subject.must_equal('') }
+        end
+
+        context 'when the line is not empty' do
+          it { subject.must_equal('Some text...') }
+        end
+      end
+
+    end # Line
+
+  end # Editor
+
+end # Vedeu