vedeu 0.6.8 → 0.6.9

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

@@ -2,48 +2,52 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Output do
+  module Output
 
-    let(:described) { Vedeu::Output }
-    let(:instance)  { described.new(output) }
-    let(:output)    {}
-    let(:drb)       { false }
+    describe Output do
 
-    before { Vedeu::Configuration.stubs(:drb?).returns(drb) }
+      let(:described) { Vedeu::Output::Output }
+      let(:instance)  { described.new(output) }
+      let(:output)    {}
+      let(:drb)       { false }
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@output').must_equal(output) }
-    end
+      before { Vedeu::Configuration.stubs(:drb?).returns(drb) }
 
-    describe '.render' do
-      before { Vedeu.renderers.stubs(:render) }
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@output').must_equal(output) }
+      end
 
-      subject { described.render(output) }
+      describe '.render' do
+        before { Vedeu.renderers.stubs(:render) }
 
-      context 'when DRb is enabled' do
-        let(:drb)            { true }
-        let(:virtual_buffer) { [] }
+        subject { described.render(output) }
 
-        before do
-          Vedeu::Configuration.stubs(:drb?).returns(drb)
-          # Vedeu::Renderers::HTML.stubs(:to_file)
-          # Vedeu::VirtualBuffers.stubs(:retrieve).returns(virtual_buffer)
-        end
+        context 'when DRb is enabled' do
+          let(:drb)            { true }
+          let(:virtual_buffer) { [] }
+
+          before do
+            Vedeu::Configuration.stubs(:drb?).returns(drb)
+            # Vedeu::Renderers::HTML.stubs(:to_file)
+            # Vedeu::Buffers::VirtualBuffers.stubs(:retrieve).returns(virtual_buffer)
+          end
 
-        it {
-          Vedeu.expects(:trigger).with(:_drb_store_output_, output)
-          subject
-        }
+          it {
+            Vedeu.expects(:trigger).with(:_drb_store_output_, output)
+            subject
+          }
+
+          # it 'writes the virtual buffer to a file' do
+          #   Vedeu::Renderers::HTML.expects(:to_file).with(virtual_buffer)
+          #   subject
+          # end
+        end
 
-        # it 'writes the virtual buffer to a file' do
-        #   Vedeu::Renderers::HTML.expects(:to_file).with(virtual_buffer)
-        #   subject
-        # end
+        it { Vedeu.renderers.expects(:render).with(output); subject }
       end
 
-      it { Vedeu.renderers.expects(:render).with(output); subject }
-    end
+    end # Output
 
   end # Output
 

data/test/lib/vedeu/output/{presentation_test.rb → presentation/presentation_test.rb}

@@ -45,22 +45,26 @@ module Vedeu
     let(:foreground) { '#aadd00' }
 
     describe '#to_s' do
+      let(:red)   {
+        Vedeu::Colours::Colour.new(foreground: '#ff0000', background: '#000000')
+      }
+      let(:green) {
+        Vedeu::Colours::Colour.new(foreground: '#00ff00', background: '#000000')
+      }
       let(:line) {
         Vedeu::Views::Line.new(value:  [],
-                               parent: Vedeu::Interface.new,
-                               colour: Vedeu::Colours::Colour.new(foreground: '#00ff00',
-                                                                  background: '#000000'),
-                               style:  Vedeu::Style.new('normal'))
+                               parent: Vedeu::Models::Interface.new,
+                               colour: green,
+                               style:  Vedeu::Presentation::Style.new('normal'))
       }
       let(:stream) {
         Vedeu::Views::Stream.new(value:  stream_value,
                                  parent: line,
-                                 colour: Vedeu::Colours::Colour.new(foreground: '#ff0000',
-                                                                    background: '#000000'),
+                                 colour: red,
                                  style:  stream_style)
       }
       let(:stream_value)  { 'Some text' }
-      let(:stream_style)  { Vedeu::Style.new(:underline) }
+      let(:stream_style)  { Vedeu::Presentation::Style.new(:underline) }
 
       it { includer.must_respond_to(:to_str) }
 

data/test/lib/vedeu/output/presentation/style_test.rb

@@ -2,79 +2,119 @@ require 'test_helper'
 
 module Vedeu
 
-  class ParentPresentationStyleTestClass
+  module Presentation
 
-    include Vedeu::Presentation
+    describe Style do
 
-    attr_reader :attributes
-    attr_reader :parent
+      let(:described) { Vedeu::Presentation::Style }
+      let(:instance)  { described.new(_value) }
+      let(:_value)    { 'bold' }
 
-    def attributes
-      {
-        style: ['underline']
-      }
-    end
+      describe 'alias methods' do
+        it { instance.must_respond_to(:escape_sequences) }
+      end
 
-  end
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@value').must_equal('bold') }
+      end
 
-  class PresentationStyleTestClass
+      describe 'accessors' do
+        it { instance.must_respond_to(:value) }
+        it { instance.must_respond_to(:value=) }
+      end
 
-    include Vedeu::Presentation
+      describe '.coerce' do
+        let(:_value) { 'bold' }
 
-    attr_reader :attributes
-    attr_reader :parent
+        subject { described.coerce(_value) }
 
-    def initialize(attributes = {})
-      @attributes = attributes
-      @parent     = @attributes[:parent]
-    end
+        it { subject.must_be_instance_of(described) }
 
-  end # PresentationTestClass
+        context 'when the value is nil' do
+          let(:_value) { nil }
 
-  module Presentation
+          it { subject.must_be_instance_of(described) }
+        end
 
-    describe Style do
+        context 'when the value is a Style already' do
+          let(:_value) { Vedeu::Presentation::Style.new('bold') }
 
-      let(:includer) { Vedeu::PresentationStyleTestClass.new(attributes) }
-      let(:attributes) {
-        {
-          parent: parent,
-          style:  style,
-        }
-      }
-      let(:parent) { Vedeu::ParentPresentationStyleTestClass.new }
-      let(:style)  { ['bold'] }
+          it 'returns the value' do
+            subject.must_equal(_value)
+          end
+        end
 
-      describe '#style' do
-        subject { includer.style }
+        context 'when the value is an Array' do
+          let(:_value)  { [:bold, :blink] }
 
-        it { subject.must_be_instance_of(Vedeu::Style) }
+          it { subject.value.must_equal([:bold, :blink]) }
+        end
+      end
 
-        context 'when the attribute is not set' do
-          let(:style) {}
+      describe '#attributes' do
+        subject { instance.attributes }
 
-          context 'when a parent is available' do
-            it { subject.value.must_equal(['underline']) }
-          end
+        it { subject.must_be_instance_of(Hash) }
+
+        it 'returns an attributes hash for this instance' do
+          subject.must_equal(style: 'bold')
+        end
+      end
+
+      describe '#eql?' do
+        let(:other) { instance }
 
-          context 'when a parent is not available' do
-            let(:parent) {}
+        subject { instance.eql?(other) }
 
-            it { subject.value.must_equal(nil) }
+        it { subject.must_equal(true) }
+
+        context 'when different to other' do
+          let(:other) { described.new('underline') }
+
+          it { subject.must_equal(false) }
+        end
+      end
+
+      describe '#to_s' do
+        let(:_value) {}
+
+        subject { instance.to_s }
+
+        it { subject.must_be_instance_of(String) }
+        it { subject.must_equal('') }
+
+        describe 'for a single style' do
+          let(:_value) { 'normal' }
+
+          it 'returns an escape sequence' do
+            subject.must_equal("\e[24m\e[22m\e[27m")
           end
         end
 
-        context 'when the attribute is set' do
-          it { subject.value.must_equal(['bold']) }
+        describe 'for multiple styles' do
+          let(:_value) { ['normal', 'underline'] }
+
+          it 'returns an escape sequence for multiple styles' do
+            subject.must_equal("\e[24m\e[22m\e[27m\e[4m")
+          end
         end
-      end
 
-      describe '#style=' do
-        let(:style) { Vedeu::Style.new('normal') }
+        describe 'for an unknown style' do
+          let(:_value) { 'unknown' }
+
+          it 'returns an empty string for an unknown style' do
+            subject.must_equal('')
+          end
+        end
 
-        subject { includer.style = (style) }
+        describe 'for an empty or nil' do
+          let(:_value) { '' }
 
-        it { subject.must_be_instance_of(Vedeu::Style) }
+          it 'returns an empty string for empty or nil' do
+            subject.must_equal('')
+          end
+        end
       end
 
     end # Style

data/test/lib/vedeu/output/presentation/styles_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+module Vedeu
+
+  class ParentPresentationStyleTestClass
+
+    include Vedeu::Presentation
+
+    attr_reader :attributes
+    attr_reader :parent
+
+    def attributes
+      {
+        style: ['underline']
+      }
+    end
+
+  end
+
+  class PresentationStyleTestClass
+
+    include Vedeu::Presentation
+
+    attr_reader :attributes
+    attr_reader :parent
+
+    def initialize(attributes = {})
+      @attributes = attributes
+      @parent     = @attributes[:parent]
+    end
+
+  end # PresentationTestClass
+
+  module Presentation
+
+    describe Styles do
+
+      let(:includer) { Vedeu::PresentationStyleTestClass.new(attributes) }
+      let(:attributes) {
+        {
+          parent: parent,
+          style:  style,
+        }
+      }
+      let(:parent) { Vedeu::ParentPresentationStyleTestClass.new }
+      let(:style)  { ['bold'] }
+
+      describe '#style' do
+        subject { includer.style }
+
+        it { subject.must_be_instance_of(Vedeu::Presentation::Style) }
+
+        context 'when the attribute is not set' do
+          let(:style) {}
+
+          context 'when a parent is available' do
+            it { subject.value.must_equal(['underline']) }
+          end
+
+          context 'when a parent is not available' do
+            let(:parent) {}
+
+            it { subject.value.must_equal(nil) }
+          end
+        end
+
+        context 'when the attribute is set' do
+          it { subject.value.must_equal(['bold']) }
+        end
+      end
+
+      describe '#style=' do
+        let(:style) { Vedeu::Presentation::Style.new('normal') }
+
+        subject { includer.style = (style) }
+
+        it { subject.must_be_instance_of(Vedeu::Presentation::Style) }
+      end
+
+    end # Style
+
+  end # Presentation
+
+end # Vedeu

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

@@ -2,151 +2,155 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Text do
-
-    let(:described) { Vedeu::Text }
-    let(:_value)    { 'Testing the Text class with various options' }
-    let(:options)   {
-      {
-        anchor:     anchor,
-        background: background,
-        colour:     colour,
-        foreground: foreground,
-        model:      model,
-        pad:        pad,
-        width:      width,
+  module Output
+
+    describe Text do
+
+      let(:described) { Vedeu::Output::Text }
+      let(:_value)    { 'Testing the Text class with various options' }
+      let(:options)   {
+        {
+          anchor:     anchor,
+          background: background,
+          colour:     colour,
+          foreground: foreground,
+          model:      model,
+          pad:        pad,
+          width:      width,
+        }
       }
-    }
-    let(:anchor)     { :left }
-    let(:background) { nil }
-    let(:colour)     { nil }
-    let(:foreground) { nil }
-    let(:model)      { nil }
-    let(:pad)        { ' ' }
-    let(:width)      { nil }
-
-    describe '.with' do
-      subject { described.with(_value, options) }
-
-      context 'when a width is provided' do
-        context 'when value longer than the width' do
-          let(:width) { 23 }
-
-          it 'returns the value truncated' do
-            subject.must_equal('Testing the Text class ')
+      let(:anchor)     { :left }
+      let(:background) { nil }
+      let(:colour)     { nil }
+      let(:foreground) { nil }
+      let(:model)      { nil }
+      let(:pad)        { ' ' }
+      let(:width)      { nil }
+
+      describe '.with' do
+        subject { described.with(_value, options) }
+
+        context 'when a width is provided' do
+          context 'when value longer than the width' do
+            let(:width) { 23 }
+
+            it 'returns the value truncated' do
+              subject.must_equal('Testing the Text class ')
+            end
           end
-        end
 
-        context 'when value is shorter or equal to the width' do
-          let(:width) { 48 }
+          context 'when value is shorter or equal to the width' do
+            let(:width) { 48 }
 
-          context 'and an anchor is not set' do
-            it 'returns the value left aligned' do
-              subject
-                .must_equal('Testing the Text class with various options     ')
+            context 'and an anchor is not set' do
+              it 'returns the value left aligned' do
+                subject
+                  .must_equal('Testing the Text class with various options     ')
+              end
             end
-          end
 
-          context 'and the anchor is set to :left' do
-            it 'returns the value left aligned' do
-              subject
-                .must_equal('Testing the Text class with various options     ')
+            context 'and the anchor is set to :left' do
+              it 'returns the value left aligned' do
+                subject
+                  .must_equal('Testing the Text class with various options     ')
+              end
             end
-          end
 
-          context 'and the anchor is set to :align' do
-            let(:anchor) { :align }
+            context 'and the anchor is set to :align' do
+              let(:anchor) { :align }
 
-            it 'returns the value left aligned' do
-              subject
-                .must_equal('Testing the Text class with various options     ')
+              it 'returns the value left aligned' do
+                subject
+                  .must_equal('Testing the Text class with various options     ')
+              end
             end
-          end
 
-          context 'and the anchor is set to centre' do
-            let(:anchor) { :centre }
+            context 'and the anchor is set to centre' do
+              let(:anchor) { :centre }
 
-            it 'returns the value centre aligned' do
-              subject
-                .must_equal('  Testing the Text class with various options   ')
+              it 'returns the value centre aligned' do
+                subject
+                  .must_equal('  Testing the Text class with various options   ')
+              end
             end
-          end
 
-          context 'and the anchor is set to right' do
-            let(:anchor) { :right }
+            context 'and the anchor is set to right' do
+              let(:anchor) { :right }
 
-            it 'returns the value right aligned' do
-              subject
-                .must_equal('     Testing the Text class with various options')
+              it 'returns the value right aligned' do
+                subject
+                  .must_equal('     Testing the Text class with various options')
+              end
             end
-          end
 
-          context 'and the anchor is invalid' do
-            let(:anchor) { :invalid }
+            context 'and the anchor is invalid' do
+              let(:anchor) { :invalid }
 
-            it 'returns the value left aligned' do
-              subject
-                .must_equal('Testing the Text class with various options     ')
+              it 'returns the value left aligned' do
+                subject
+                  .must_equal('Testing the Text class with various options     ')
+              end
             end
           end
         end
-      end
 
-      context 'when a width is not provided' do
-        let(:width) {}
-        let(:_value) { 'some value' }
+        context 'when a width is not provided' do
+          let(:width) {}
+          let(:_value) { 'some value' }
 
-        it 'returns the value as a string' do
-          subject.must_equal('some value')
+          it 'returns the value as a string' do
+            subject.must_equal('some value')
+          end
         end
       end
-    end
 
-    describe '.add' do
-      subject { described.add(value, options) }
+      describe '.add' do
+        subject { described.add(value, options) }
 
-      context 'when the model is a Vedeu::Views::View' do
-        let(:model) { Vedeu::Views::View.new }
+        context 'when the model is a Vedeu::Views::View' do
+          let(:model) { Vedeu::Views::View.new }
 
-        it { subject.must_be_instance_of(Vedeu::Views::Lines) }
-      end
+          it { subject.must_be_instance_of(Vedeu::Views::Lines) }
+        end
 
-      context 'when the model is a Vedeu::Views::Line' do
-        let(:model) { Vedeu::Views::Line.new }
+        context 'when the model is a Vedeu::Views::Line' do
+          let(:model) { Vedeu::Views::Line.new }
 
-        it { subject.must_be_instance_of(Vedeu::Views::Streams) }
-      end
+          it { subject.must_be_instance_of(Vedeu::Views::Streams) }
+        end
 
-      context 'when the model is a Vedeu::Views::Stream' do
-        let(:parent) { Vedeu::Views::Line.new }
-        let(:model)  { Vedeu::Views::Stream.new(parent: parent) }
+        context 'when the model is a Vedeu::Views::Stream' do
+          let(:parent) { Vedeu::Views::Line.new }
+          let(:model)  { Vedeu::Views::Stream.new(parent: parent) }
 
-        it { subject.must_be_instance_of(Vedeu::Views::Streams) }
-      end
+          it { subject.must_be_instance_of(Vedeu::Views::Streams) }
+        end
 
-      context 'when the model is not given' do
-        let(:model) {}
+        context 'when the model is not given' do
+          let(:model) {}
 
-        it { subject.must_be_instance_of(NilClass) }
-      end
+          it { subject.must_be_instance_of(NilClass) }
+        end
 
-      context 'when the colour option is given' do
-        let(:colour) { { background: '#33ff33', foreground: '#ffaa00' } }
+        context 'when the colour option is given' do
+          let(:colour) { { background: '#33ff33', foreground: '#ffaa00' } }
 
-        # @todo Add more tests.
-        # it { skip }
-      end
+          # @todo Add more tests.
+          # it { skip }
+        end
 
-      context 'when the background and/or foreground options are given' do
-        let(:background) { '#111111' }
-        let(:foreground) { '#aadd00' }
+        context 'when the background and/or foreground options are given' do
+          let(:background) { '#111111' }
+          let(:foreground) { '#aadd00' }
+
+          # @todo Add more tests.
+          # it { skip }
+        end
 
-        # @todo Add more tests.
-        # it { skip }
       end
 
-    end
+    end # Text
 
-  end # Text
+  end # Output
 
 end # Vedeu