vedeu 0.5.13 → 0.6.0

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

@@ -0,0 +1,561 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Editor
+
+    describe Lines do
+
+      let(:described) { Vedeu::Editor::Lines }
+      let(:instance)  { described.new(lines) }
+      let(:lines)     {
+        [
+          Vedeu::Editor::Line.new('Some text...'),
+          Vedeu::Editor::Line.new('More text...'),
+          Vedeu::Editor::Line.new('Other text...')
+        ]
+      }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@lines').must_equal(lines) }
+
+        context 'when lines were not given' do
+          let(:lines) {}
+
+          it { instance.instance_variable_get('@lines').must_equal([]) }
+        end
+      end
+
+      describe 'accessors' do
+        it { instance.must_respond_to(:lines) }
+        it { instance.must_respond_to(:lines=) }
+      end
+
+      describe '.coerce' do
+        let(:document) {}
+
+        subject { described.coerce(document) }
+
+        it { subject.must_be_instance_of(described) }
+
+        context 'when the document is already a Vedeu::Editor::Lines object' do
+          let(:document) { Vedeu::Editor::Lines.new(lines) }
+
+          it { subject.must_equal(document) }
+          it { subject.lines.must_equal(lines) }
+        end
+
+        context 'when the document is an empty Array' do
+          let(:document) { [] }
+
+          it { subject.lines.must_equal([]) }
+        end
+
+        context 'when the document is an Array' do
+          let(:document) {
+            [
+              Vedeu::Editor::Line.new('Some text...'),
+              :more_text,
+              'Other text...',
+            ]
+          }
+          let(:expected) {
+            [
+              Vedeu::Editor::Line.new('Some text...'),
+              Vedeu::Editor::Line.new(''),
+              Vedeu::Editor::Line.new('Other text...'),
+            ]
+          }
+
+          it { subject.lines.must_equal(expected) }
+        end
+
+        context 'when the document is a String' do
+          let(:document) { "Some text...\nMore text..." }
+
+          context 'but it is empty' do
+            let(:document) { '' }
+
+            it { subject.must_equal(Vedeu::Editor::Lines.new) }
+          end
+
+          context 'but it has no line breaks' do
+
+          end
+        end
+      end
+
+      describe '#[]' do
+        subject { instance.[](index) }
+
+        context 'when index is a Fixnum' do
+          let(:index)    { 2 }
+          let(:expected) {
+            Vedeu::Editor::Line.new('Other text...')
+          }
+
+          it { subject.must_equal(expected) }
+        end
+
+        context 'when index is a Range' do
+          let(:index)    { (1..2) }
+          let(:expected) {
+            [
+              Vedeu::Editor::Line.new('More text...'),
+              Vedeu::Editor::Line.new('Other text...')
+            ]
+          }
+
+          it { subject.must_equal(expected) }
+        end
+      end
+
+      describe '#delete_character' do
+        let(:x)         { 0 }
+        let(:y)         { 0 }
+
+        subject { instance.delete_character(y, x) }
+
+        context 'when there are no lines' do
+          let(:lines) {
+            [
+              Vedeu::Editor::Line.new('')
+            ]
+          }
+          let(:expected) {
+            Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new('')])
+          }
+
+          it { subject.must_equal(expected) }
+        end
+
+        context 'when there is one line' do
+          let(:lines) {
+            [
+              Vedeu::Editor::Line.new('Hydrogen')
+            ]
+          }
+
+          context 'and x is the first character of the line' do
+            let(:x) { 0 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new('Hydrogen')])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and x is somewhere on the line' do
+            let(:x) { 4 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new('Hydrgen')])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and x is the last character of the line' do
+            let(:x) { 15 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new('Hydroge')])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+        end
+
+        context 'when there are multiple lines' do
+          let(:y)     { 1 }
+          let(:lines) {
+            [
+              Vedeu::Editor::Line.new('Hydrogen'),
+              Vedeu::Editor::Line.new('Helium'),
+              Vedeu::Editor::Line.new('Lithium'),
+            ]
+          }
+
+          context 'and x is the first character of the line' do
+            let(:x) { 0 }
+            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
+
+          context 'and x is somewhere on the line' do
+            let(:x) { 4 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([
+                Vedeu::Editor::Line.new('Hydrogen'),
+                Vedeu::Editor::Line.new('Helim'),
+                Vedeu::Editor::Line.new('Lithium'),
+              ])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and x is the last character of the line' do
+            let(:x) { 15 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([
+                Vedeu::Editor::Line.new('Hydrogen'),
+                Vedeu::Editor::Line.new('Heliu'),
+                Vedeu::Editor::Line.new('Lithium'),
+              ])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+        end
+      end
+
+      describe '#delete_line' do
+        let(:index) { 1 }
+
+        subject { instance.delete_line(index) }
+
+        it { subject.must_be_instance_of(described) }
+
+        context 'when the lines are empty' do
+          let(:lines) { [] }
+
+          it { subject.must_equal(Vedeu::Editor::Lines.new) }
+        end
+
+        context 'when the lines are not empty' do
+          context 'when an index is not given' do
+            let(:index) {}
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Some text...', 'More text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'when a negative index is given' do
+            let(:index) { -4 }
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Some text...', 'More text...', 'Other text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'when an index is given' do
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Some text...', 'Other text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'when an index of the last line is given' do
+            let(:index) { 2 }
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Some text...', 'More text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'when an index greater than the number of lines is given' do
+            let(:index) { 10 }
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Some text...', 'More text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+        end
+      end
+
+      describe '#empty?' do
+        subject { instance.empty? }
+
+        context 'when the line is empty' do
+          let(:lines) {}
+
+          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(:x)         { 0 }
+        let(:y)         { 0 }
+        let(:character) { 'a' }
+
+        subject { instance.insert_character(character, y, x) }
+
+        context 'when there are no lines' do
+          let(:lines) {
+            [
+              Vedeu::Editor::Line.new('')
+            ]
+          }
+          let(:expected) {
+            Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new('a')])
+          }
+
+          it { subject.must_equal(expected) }
+        end
+
+        context 'when there is one line' do
+          let(:lines) {
+            [
+              Vedeu::Editor::Line.new('Hydrogen')
+            ]
+          }
+
+          context 'and x is the first character of the line' do
+            let(:x) { 0 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new('aHydrogen')])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and x is somewhere on the line' do
+            let(:x) { 4 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new('Hydraogen')])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and x is the last character of the line' do
+            let(:x) { 15 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new('Hydrogena')])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+        end
+
+        context 'when there are multiple lines' do
+          let(:y)     { 1 }
+          let(:lines) {
+            [
+              Vedeu::Editor::Line.new('Hydrogen'),
+              Vedeu::Editor::Line.new('Helium'),
+              Vedeu::Editor::Line.new('Lithium'),
+            ]
+          }
+
+          context 'and x is the first character of the line' do
+            let(:x) { 0 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([
+                Vedeu::Editor::Line.new('Hydrogen'),
+                Vedeu::Editor::Line.new('aHelium'),
+                Vedeu::Editor::Line.new('Lithium'),
+              ])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and x is somewhere on the line' do
+            let(:x) { 4 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([
+                Vedeu::Editor::Line.new('Hydrogen'),
+                Vedeu::Editor::Line.new('Heliaum'),
+                Vedeu::Editor::Line.new('Lithium'),
+              ])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and x is the last character of the line' do
+            let(:x) { 15 }
+            let(:expected) {
+              Vedeu::Editor::Lines.new([
+                Vedeu::Editor::Line.new('Hydrogen'),
+                Vedeu::Editor::Line.new('Heliuma'),
+                Vedeu::Editor::Line.new('Lithium'),
+              ])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+        end
+      end
+
+      describe '#insert_line' do
+        let(:line)  { "Many text..." }
+        let(:index) { 1 }
+
+        subject { instance.insert_line(line, index) }
+
+        it { subject.must_be_instance_of(described) }
+
+        context 'when a line is not given' do
+          let(:line) {}
+          let(:expected) {
+            Vedeu::Editor::Lines.coerce(['Some text...', 'More text...', 'Other text...'])
+          }
+
+          it { subject.must_equal(expected) }
+        end
+
+        context 'when a line is given' do
+          context 'and an index is not given' do
+            let(:index) {}
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Some text...', 'More text...', 'Other text...', 'Many text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and a negative index is given' do
+            let(:index) { -4 }
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Many text...', 'Some text...', 'More text...', 'Other text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and an index is given' do
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Some text...', 'Many text...', 'More text...', 'Other text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and an index of the last line is given' do
+            let(:index) { 5 }
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Some text...', 'More text...', 'Other text...', 'Many text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'and an index greater than the number of lines is given' do
+            let(:index) { 10 }
+            let(:expected) {
+              Vedeu::Editor::Lines.coerce(['Some text...', 'More text...', 'Other text...', 'Many text...'])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+        end
+      end
+
+      describe '#line' do
+        let(:index) { 1 }
+
+        subject { instance.line(index) }
+
+        it { subject.must_be_instance_of(Vedeu::Editor::Line) }
+
+        context 'when there are no lines' do
+          let(:lines) {}
+
+          it { subject.must_equal(Vedeu::Editor::Line.new) }
+        end
+
+        context 'when there are lines' do
+          context 'and an index is not given' do
+            let(:index) {}
+
+            it 'returns the last line' do
+              subject.must_equal(Vedeu::Editor::Line.new('Other text...'))
+            end
+          end
+
+          context 'and an index is given' do
+            context 'and a negative index is given' do
+              let(:index) { -4 }
+
+              it 'returns the first line' do
+                subject.must_equal(Vedeu::Editor::Line.new('Some text...'))
+              end
+            end
+
+            context 'and an index is given' do
+              it { subject.must_equal(Vedeu::Editor::Line.new('More text...')) }
+            end
+
+            context 'and an index of the last line is given' do
+              let(:index) { 5 }
+
+              it { subject.must_equal(Vedeu::Editor::Line.new('Other text...')) }
+            end
+
+            context 'and an index greater than the number of lines is given' do
+              let(:index) { 10 }
+
+              it { subject.must_equal(Vedeu::Editor::Line.new('Other text...')) }
+            end
+          end
+        end
+      end
+
+      describe '#size' do
+        subject { instance.size }
+
+        context 'when there are no lines' do
+          let(:lines) {}
+
+          it { subject.must_equal(0) }
+        end
+
+        context 'when there are lines' do
+          it { subject.must_equal(3) }
+        end
+      end
+
+      describe '#to_s' do
+        subject { instance.to_s }
+
+        context 'when there are no lines' do
+          let(:lines) {}
+
+          it { subject.must_equal("") }
+        end
+
+        context 'when there are lines' do
+          let(:expected) { "Some text...More text...Other text..." }
+
+          it { subject.must_equal(expected) }
+        end
+      end
+
+    end # Lines
+
+  end # Editor
+
+end # Vedeu