vedeu 0.6.8 → 0.6.9

data/test/lib/vedeu/models/interfaces_test.rb

@@ -2,33 +2,37 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Interfaces do
+  module Models
 
-    let(:described) { Vedeu::Interfaces }
+    describe Interfaces do
 
-    it { described.must_respond_to(:interfaces) }
+      let(:described) { Vedeu::Models::Interfaces }
 
-    describe '#zindexed' do
-      before do
-        Vedeu.interfaces.reset
+      it { described.must_respond_to(:interfaces) }
 
-        @hydrogen = Vedeu.interface('hydrogen') do
-          zindex 2
-        end
-        @helium = Vedeu.interface('helium') do
-          zindex 3
-        end
-        @lithium = Vedeu.interface('lithium') do
-          zindex 1
+      describe '#zindexed' do
+        before do
+          Vedeu.interfaces.reset
+
+          @hydrogen = Vedeu.interface('hydrogen') do
+            zindex 2
+          end
+          @helium = Vedeu.interface('helium') do
+            zindex 3
+          end
+          @lithium = Vedeu.interface('lithium') do
+            zindex 1
+          end
         end
-      end
-      after { Vedeu.interfaces.reset }
+        after { Vedeu.interfaces.reset }
+
+        subject { Vedeu.interfaces.zindexed }
 
-      subject { Vedeu.interfaces.zindexed }
+        it { subject.must_equal([@lithium, @hydrogen, @helium]) }
+      end
 
-      it { subject.must_equal([@lithium, @hydrogen, @helium]) }
-    end
+    end # Interfaces
 
-  end # Interfaces
+  end # Models
 
 end # Vedeu

data/test/lib/vedeu/models/views/char_test.rb

@@ -158,10 +158,10 @@ module Vedeu
         end
 
         context 'when a style is specified' do
-          let(:style) { Vedeu::Style.new('underline') }
+          let(:style) { Vedeu::Presentation::Style.new('underline') }
 
           context 'when a parent style is specified' do
-            let(:parent_style) { Vedeu::Style.new('bold') }
+            let(:parent_style) { Vedeu::Presentation::Style.new('bold') }
 
             it { subject.must_equal("\e[4ma") }
           end

data/test/lib/vedeu/models/views/line_test.rb

@@ -20,18 +20,22 @@ module Vedeu
         [
           Vedeu::Views::Stream.new(value: 'Something interesting ',
                                    parent: streams_parent,
-                                   colour: Vedeu::Colours::Colour.new(foreground: '#ffff00'),
-                                   style:  Vedeu::Style.new('normal')),
+                                   colour: yellow,
+                                   style:  normal_style),
           Vedeu::Views::Stream.new(value: 'on this line ',
                                    parent: streams_parent,
-                                   colour: Vedeu::Colours::Colour.new(foreground: '#00ff00'),
-                                   style:  Vedeu::Style.new('normal')),
+                                   colour: green,
+                                   style:  normal_style),
           Vedeu::Views::Stream.new(value: 'would be cool, eh?',
                                    parent: streams_parent,
-                                   colour: Vedeu::Colours::Colour.new(foreground: '#0000ff'),
-                                   style:  Vedeu::Style.new('normal'))
+                                   colour: blue,
+                                   style:  normal_style)
         ]
       }
+      let(:yellow)       { Vedeu::Colours::Colour.new(foreground: '#ffff00') }
+      let(:green)        { Vedeu::Colours::Colour.new(foreground: '#00ff00') }
+      let(:blue)         { Vedeu::Colours::Colour.new(foreground: '#0000ff') }
+      let(:normal_style) { Vedeu::Presentation::Style.new('normal') }
 
       let(:streams_parent) {
         Vedeu::Views::Line.new(value:  nil,
@@ -41,10 +45,10 @@ module Vedeu
       }
 
       let(:parent) { Vedeu::Views::View.new(name: 'Vedeu::Line') }
+      let(:style)  { Vedeu::Presentation::Style.new('normal') }
       let(:colour) {
         Vedeu::Colours::Colour.new(foreground: '#ff0000', background: '#000000')
       }
-      let(:style)  { Vedeu::Style.new('normal') }
 
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }

data/test/lib/vedeu/models/views/stream_test.rb

@@ -29,7 +29,7 @@ module Vedeu
       let(:colour)      {
         Vedeu::Colours::Colour.new(background: '#ff0000', foreground: '#000000')
       }
-      let(:style)       { Vedeu::Style.new('normal') }
+      let(:style)       { Vedeu::Presentation::Style.new('normal') }
       let(:line_parent) { Vedeu::Views::View.new(name: 'Vedeu::Views::Stream') }
 
       describe '#initialize' do

data/test/lib/vedeu/models/views/view_test.rb

@@ -86,7 +86,7 @@ module Vedeu
         subject { instance.visible? }
 
         context 'when the interface is visible' do
-          let(:interface) { Vedeu::Interface.new(visible: true) }
+          let(:interface) { Vedeu::Models::Interface.new(visible: true) }
 
           before do
             Vedeu.interfaces.stubs(:by_name).with(_name).returns(interface)

data/test/lib/vedeu/output/clear/named_group_test.rb

@@ -16,7 +16,7 @@ module Vedeu
       end
 
       describe '.render' do
-        let(:group) { Vedeu::Group.new(members: [_name]) }
+        let(:group) { Vedeu::Models::Group.new(members: [_name]) }
 
         before { Vedeu.groups.stubs(:by_name).returns(group) }
 

data/test/lib/vedeu/output/clear/named_interface_test.rb

@@ -22,7 +22,9 @@ module Vedeu
       end
 
       describe '#render' do
-        let(:interface) { Vedeu::Interface.new(name: _name, visible: visible) }
+        let(:interface) {
+          Vedeu::Models::Interface.new(name: _name, visible: visible)
+        }
         let(:visible)   { true }
         let(:geometry)  {
           Vedeu::Geometry::Geometry.new(name: _name, x: 1, y: 1, xn: 2, yn: 2)

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

@@ -2,143 +2,147 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Compressor do
-
-    let(:described) { Vedeu::Compressor }
-    let(:instance)  { described.new(output) }
-    let(:output)    {}
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@output').must_equal(output) }
-      it { instance.instance_variable_get('@colour').must_equal('') }
-      it { instance.instance_variable_get('@style').must_equal('') }
-    end
-
-    describe '.render' do
-      subject { described.render(output) }
-
-      it { subject.must_be_instance_of(String) }
-
-      context 'when compression is enabled' do
-        before { Vedeu.configure { compression(true) } }
-
-        context 'when the output is all Vedeu::Views::Char elements' do
-          let(:output) {
-            [
-              Vedeu::Views::Char.new(value:  'Y',
-                                     colour: { foreground: '#ff0000' }),
-              Vedeu::Views::Char.new(value:  'e',
-                                     colour: { foreground: '#ff0000' }),
-              Vedeu::Views::Char.new(value:  's',
-                                     colour: { foreground: '#ff0000' }),
-            ]
-          }
-          it 'converts the non-Vedeu::Views::Char elements into String ' \
-             'elements' do
-            subject.must_equal("\e[38;2;255;0;0mYes")
+  module Output
+
+    describe Compressor do
+
+      let(:described) { Vedeu::Output::Compressor }
+      let(:instance)  { described.new(output) }
+      let(:output)    {}
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@output').must_equal(output) }
+        it { instance.instance_variable_get('@colour').must_equal('') }
+        it { instance.instance_variable_get('@style').must_equal('') }
+      end
+
+      describe '.render' do
+        subject { described.render(output) }
+
+        it { subject.must_be_instance_of(String) }
+
+        context 'when compression is enabled' do
+          before { Vedeu.configure { compression(true) } }
+
+          context 'when the output is all Vedeu::Views::Char elements' do
+            let(:output) {
+              [
+                Vedeu::Views::Char.new(value:  'Y',
+                                       colour: { foreground: '#ff0000' }),
+                Vedeu::Views::Char.new(value:  'e',
+                                       colour: { foreground: '#ff0000' }),
+                Vedeu::Views::Char.new(value:  's',
+                                       colour: { foreground: '#ff0000' }),
+              ]
+            }
+            it 'converts the non-Vedeu::Views::Char elements into String ' \
+               'elements' do
+              subject.must_equal("\e[38;2;255;0;0mYes")
+            end
           end
-        end
 
-        context 'when the output is all Vedeu::Views::Char elements' do
-          let(:output) {
-            [
-              Vedeu::Views::Char.new(value:  'a',
-                                     colour: { foreground: '#ff0000' }),
-              Vedeu::Views::Char.new(value:  'b',
-                                     colour: { foreground: '#ff0000' }),
-              Vedeu::Views::Char.new(value:  'c',
-                                     colour: { foreground: '#0000ff' }),
-              Vedeu::Views::Char.new(value:  'd',
-                                     colour: { foreground: '#0000ff' }),
-            ]
-          }
-          it 'compresses multiple colours and styles where possible' do
-            subject.must_equal("\e[38;2;255;0;0mab\e[38;2;0;0;255mcd")
+          context 'when the output is all Vedeu::Views::Char elements' do
+            let(:output) {
+              [
+                Vedeu::Views::Char.new(value:  'a',
+                                       colour: { foreground: '#ff0000' }),
+                Vedeu::Views::Char.new(value:  'b',
+                                       colour: { foreground: '#ff0000' }),
+                Vedeu::Views::Char.new(value:  'c',
+                                       colour: { foreground: '#0000ff' }),
+                Vedeu::Views::Char.new(value:  'd',
+                                       colour: { foreground: '#0000ff' }),
+              ]
+            }
+            it 'compresses multiple colours and styles where possible' do
+              subject.must_equal("\e[38;2;255;0;0mab\e[38;2;0;0;255mcd")
+            end
           end
-        end
 
-        context 'when the output is not all Vedeu::Views::Char ' \
-                'elements' do
-          let(:output) {
-            [
-              Vedeu::Views::Char.new(value: 'N'),
-              Vedeu::Models::Escape.new(value: "\e[?25l"),
-              Vedeu::Views::Char.new(value: 't'),
-            ]
-          }
-          it 'converts the non-Vedeu::Views::Char elements into String ' \
-             'elements' do
-            subject.must_equal("N\e[1;1H\e[?25lt")
+          context 'when the output is not all Vedeu::Views::Char ' \
+                  'elements' do
+            let(:output) {
+              [
+                Vedeu::Views::Char.new(value: 'N'),
+                Vedeu::Models::Escape.new(value: "\e[?25l"),
+                Vedeu::Views::Char.new(value: 't'),
+              ]
+            }
+            it 'converts the non-Vedeu::Views::Char elements into String ' \
+               'elements' do
+              subject.must_equal("N\e[1;1H\e[?25lt")
+            end
           end
         end
-      end
 
-      context 'when compression is not enabled' do
-        before { Vedeu.configure { compression(false) } }
-
-        context 'when the output is all Vedeu::Views::Char elements' do
-          let(:output) {
-            [
-              Vedeu::Views::Char.new(value:  'Y',
-                                     colour: { foreground: '#ff0000' }),
-              Vedeu::Views::Char.new(value:  'e',
-                                     colour: { foreground: '#ff0000' }),
-              Vedeu::Views::Char.new(value:  's',
-                                     colour: { foreground: '#ff0000' }),
-            ]
-          }
-          it 'converts the non-Vedeu::Views::Char elements into String ' \
-             'elements' do
-            subject.must_equal(
-              "\e[38;2;255;0;0mY\e[38;2;255;0;0me\e[38;2;255;0;0ms"
-            )
+        context 'when compression is not enabled' do
+          before { Vedeu.configure { compression(false) } }
+
+          context 'when the output is all Vedeu::Views::Char elements' do
+            let(:output) {
+              [
+                Vedeu::Views::Char.new(value:  'Y',
+                                       colour: { foreground: '#ff0000' }),
+                Vedeu::Views::Char.new(value:  'e',
+                                       colour: { foreground: '#ff0000' }),
+                Vedeu::Views::Char.new(value:  's',
+                                       colour: { foreground: '#ff0000' }),
+              ]
+            }
+            it 'converts the non-Vedeu::Views::Char elements into String ' \
+               'elements' do
+              subject.must_equal(
+                "\e[38;2;255;0;0mY\e[38;2;255;0;0me\e[38;2;255;0;0ms"
+              )
+            end
           end
-        end
 
-        context 'when the output is all Vedeu::Views::Char elements' do
-          let(:output) {
-            [
-              Vedeu::Views::Char.new(value:  'a',
-                                     colour: { foreground: '#ff0000' }),
-              Vedeu::Views::Char.new(value:  'b',
-                                     colour: { foreground: '#ff0000' }),
-              Vedeu::Views::Char.new(value:  'c',
-                                     colour: { foreground: '#0000ff' }),
-              Vedeu::Views::Char.new(value:  'd',
-                                     colour: { foreground: '#0000ff' }),
-            ]
-          }
-          it 'compresses multiple colours and styles where possible' do
-            subject.must_equal(
-              "\e[38;2;255;0;0ma" \
-              "\e[38;2;255;0;0mb" \
-              "\e[38;2;0;0;255mc" \
-              "\e[38;2;0;0;255md"
-            )
+          context 'when the output is all Vedeu::Views::Char elements' do
+            let(:output) {
+              [
+                Vedeu::Views::Char.new(value:  'a',
+                                       colour: { foreground: '#ff0000' }),
+                Vedeu::Views::Char.new(value:  'b',
+                                       colour: { foreground: '#ff0000' }),
+                Vedeu::Views::Char.new(value:  'c',
+                                       colour: { foreground: '#0000ff' }),
+                Vedeu::Views::Char.new(value:  'd',
+                                       colour: { foreground: '#0000ff' }),
+              ]
+            }
+            it 'compresses multiple colours and styles where possible' do
+              subject.must_equal(
+                "\e[38;2;255;0;0ma" \
+                "\e[38;2;255;0;0mb" \
+                "\e[38;2;0;0;255mc" \
+                "\e[38;2;0;0;255md"
+              )
+            end
           end
-        end
 
-        context 'when the output is not all Vedeu::Views::Char elements' do
-          let(:output) {
-            [
-              Vedeu::Views::Char.new(value: 'N'),
-              Vedeu::Models::Escape.new(value: "\e[?25l"),
-              Vedeu::Views::Char.new(value: 't'),
-            ]
-          }
-          it 'converts the non-Vedeu::Views::Char elements into String ' \
-             'elements' do
-            subject.must_equal("N\e[1;1H\e[?25lt")
+          context 'when the output is not all Vedeu::Views::Char elements' do
+            let(:output) {
+              [
+                Vedeu::Views::Char.new(value: 'N'),
+                Vedeu::Models::Escape.new(value: "\e[?25l"),
+                Vedeu::Views::Char.new(value: 't'),
+              ]
+            }
+            it 'converts the non-Vedeu::Views::Char elements into String ' \
+               'elements' do
+              subject.must_equal("N\e[1;1H\e[?25lt")
+            end
           end
         end
       end
-    end
 
-    describe '#render' do
-      it { instance.must_respond_to(:render) }
-    end
+      describe '#render' do
+        it { instance.must_respond_to(:render) }
+      end
+
+    end # Compressor
 
-  end # Compressor
+  end # Output
 
 end # Vedeu

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

@@ -2,69 +2,75 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Direct do
+  module Output
 
-    let(:described) { Vedeu::Direct }
-    let(:instance)  { described.new(value: _value, x: x, y: y) }
-    let(:_value)    {}
-    let(:x)         {}
-    let(:y)         {}
+    describe Direct do
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
+      let(:described) { Vedeu::Output::Direct }
+      let(:instance)  { described.new(value: _value, x: x, y: y) }
+      let(:_value)    {}
+      let(:x)         {}
+      let(:y)         {}
 
-      context 'when no value is given' do
-        it { instance.instance_variable_get('@value').must_equal('') }
-      end
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
 
-      context 'when a value is given' do
-        let(:_value) { 'some value' }
+        context 'when no value is given' do
+          it { instance.instance_variable_get('@value').must_equal('') }
+        end
 
-        it { instance.instance_variable_get('@value').must_equal('some value') }
-      end
+        context 'when a value is given' do
+          let(:_value) { 'some value' }
 
-      context 'when no x is given' do
-        it { instance.instance_variable_get('@x').must_equal(1) }
-      end
+          it {
+            instance.instance_variable_get('@value').must_equal('some value')
+          }
+        end
 
-      context 'when an x is given' do
-        let(:x) { 6 }
-        it { instance.instance_variable_get('@x').must_equal(6) }
-      end
+        context 'when no x is given' do
+          it { instance.instance_variable_get('@x').must_equal(1) }
+        end
 
-      context 'when no y is given' do
-        it { instance.instance_variable_get('@y').must_equal(1) }
-      end
+        context 'when an x is given' do
+          let(:x) { 6 }
+          it { instance.instance_variable_get('@x').must_equal(6) }
+        end
+
+        context 'when no y is given' do
+          it { instance.instance_variable_get('@y').must_equal(1) }
+        end
 
-      context 'when a y is given' do
-        let(:y) { 3 }
+        context 'when a y is given' do
+          let(:y) { 3 }
 
-        it { instance.instance_variable_get('@y').must_equal(3) }
+          it { instance.instance_variable_get('@y').must_equal(3) }
+        end
       end
-    end
 
-    describe '.write' do
-      before { Vedeu::Terminal.stubs(:output) }
+      describe '.write' do
+        before { Vedeu::Terminal.stubs(:output) }
+
+        subject { described.write(value: _value, x: x, y: y) }
 
-      subject { described.write(value: _value, x: x, y: y) }
+        it { subject.must_be_instance_of(String) }
 
-      it { subject.must_be_instance_of(String) }
+        context 'when a value is given' do
+          let(:_value) { 'some value' }
 
-      context 'when a value is given' do
-        let(:_value) { 'some value' }
+          it { subject.must_equal("\e[1;1Hsome value") }
+        end
 
-        it { subject.must_equal("\e[1;1Hsome value") }
+        context 'when a value is not given' do
+          it { subject.must_equal("\e[1;1H") }
+        end
       end
 
-      context 'when a value is not given' do
-        it { subject.must_equal("\e[1;1H") }
+      describe '#write' do
+        it { instance.must_respond_to(:write) }
       end
-    end
 
-    describe '#write' do
-      it { instance.must_respond_to(:write) }
-    end
+    end # Direct
 
-  end # Direct
+  end # Output
 
 end # Vedeu