vedeu 0.2.11 → 0.2.12

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

@@ -4,33 +4,36 @@ module Vedeu
 
   describe Char do
 
-    let(:char)       { Char.new(attributes) }
+    let(:described) { Char.new(attributes) }
+    let(:char)   { Char.new(attributes) }
+    let(:parent) {
+      {
+        colour: {
+          foreground: '#00ff00',
+          background: '#ff00ff'
+        },
+        style: []
+      }
+    }
     let(:attributes) {
       {
         colour: { foreground: '#ffff00', background: '#0000ff' },
-        parent: {
-          colour: {
-            foreground: '#00ff00',
-            background: '#ff00ff'
-          },
-          style: []
-        },
+        parent: parent,
         style:  [],
         value:  value,
       }
     }
-    let(:value) { 'a' }
+    let(:value)   { 'a' }
 
     describe '#initialize' do
-      it 'returns a new instance of Char' do
-        char.must_be_instance_of(Char)
-      end
+      it { return_type_for(described, Char) }
+      it { assigns(described, '@attributes', attributes) }
+      it { assigns(described, '@parent', parent) }
+      it { assigns(described, '@value', value) }
     end
 
     describe '#to_s' do
-      it 'returns a String' do
-        char.to_s.must_be_instance_of(String)
-      end
+      it { return_type_for(described.to_s, String) }
 
       it 'returns the escape sequences and content' do
         # - char colours and style as set in Stream#chars.

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

@@ -5,15 +5,14 @@ require 'json'
 module Vedeu
 
   describe Composition do
+    let(:described)  { Composition.new(attributes) }
+    let(:attributes) { {} }
 
     before { Buffers.reset }
 
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        attributes = {}
-
-        Composition.new(attributes).must_be_instance_of(Composition)
-      end
+      it { return_type_for(described, Composition) }
+      it { assigns(described, '@attributes', { interfaces: [] }) }
     end
 
     describe '#interfaces' do
@@ -31,13 +30,13 @@ module Vedeu
       end
 
       it 'returns an empty collection when no interfaces are associated' do
-        Composition.new.interfaces.must_be_empty
+        described.interfaces.must_be_empty
       end
     end
 
     describe '#method_missing' do
       it 'returns nil' do
-        Composition.new.some_missing_method(:test).must_equal(nil)
+        described.some_missing_method(:test).must_equal(nil)
       end
     end
 

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

@@ -4,83 +4,82 @@ module Vedeu
 
   describe Geometry do
 
+    let(:described)  { Geometry.new(attributes) }
+    let(:attributes) { {} }
+
+    before do
+      IO.console.stubs(:winsize).returns([25, 80])
+    end
+
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        attributes = {}
-        Geometry.new(attributes).must_be_instance_of(Geometry)
-      end
+      it { return_type_for(described, Geometry) }
+      it { assigns(described, '@attributes', {
+          centred: false,
+          height:  25,
+          width:   80,
+          x:       1,
+          xn:      nil,
+          y:       1,
+          yn:      nil,
+        })
+      }
+      it { assigns(described, '@centred', false) }
+      it { assigns(described, '@height', 25) }
+      it { assigns(described, '@width', 80) }
     end
 
     describe '#y' do
       it 'returns the value of y when it is a proc' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ y: proc { 17 } })
-          geometry.y.must_equal(17)
-        end
+        geometry = Geometry.new({ y: proc { 17 } })
+        geometry.y.must_equal(17)
       end
 
       it 'returns the value of y when just an attribute' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ y: 19 })
-          geometry.y.must_equal(19)
-        end
+        geometry = Geometry.new({ y: 19 })
+        geometry.y.must_equal(19)
       end
     end
 
     describe '#yn' do
       it 'returns the value of yn when it is a proc' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ yn: proc { 17 } })
-          geometry.yn.must_equal(17)
-        end
+        geometry = Geometry.new({ yn: proc { 17 } })
+        geometry.yn.must_equal(17)
       end
 
       it 'returns the value of yn when just an attribute' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ yn: 19 })
-          geometry.yn.must_equal(19)
-        end
+        geometry = Geometry.new({ yn: 19 })
+        geometry.yn.must_equal(19)
       end
     end
 
     describe '#x' do
       it 'returns the value of x when it is a proc' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ x: proc { 58 } })
-          geometry.x.must_equal(58)
-        end
+        geometry = Geometry.new({ x: proc { 58 } })
+        geometry.x.must_equal(58)
       end
 
       it 'returns the value of x when just an attribute' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ x: 64 })
-          geometry.x.must_equal(64)
-        end
+        geometry = Geometry.new({ x: 64 })
+        geometry.x.must_equal(64)
       end
     end
 
     describe '#xn' do
       it 'returns the value of xn when it is a proc' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ xn: proc { 58 } })
-          geometry.xn.must_equal(58)
-        end
+        geometry = Geometry.new({ xn: proc { 58 } })
+        geometry.xn.must_equal(58)
       end
 
       it 'returns the value of xn when just an attribute' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ xn: 64 })
-          geometry.xn.must_equal(64)
-        end
+        geometry = Geometry.new({ xn: 64 })
+        geometry.xn.must_equal(64)
       end
     end
 
     describe '#width' do
       it 'returns the viewport width when the interface fits the terminal' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ width: 60, height: 1, x: 5, y: 1 })
-          geometry.width.must_equal(60)
-        end
+        geometry = Geometry.new({ width: 60, height: 1, x: 5, y: 1 })
+        geometry.width.must_equal(60)
       end
 
       it 'returns the viewport width when the interface does not fit the ' \
@@ -101,10 +100,8 @@ module Vedeu
 
     describe '#height' do
       it 'returns the viewport height when the interface fits the terminal' do
-        IO.console.stub(:winsize, [25, 80]) do
-          geometry = Geometry.new({ width: 5, height: 20, x: 1, y: 5 })
-          geometry.height.must_equal(20)
-        end
+        geometry = Geometry.new({ width: 5, height: 20, x: 1, y: 5 })
+        geometry.height.must_equal(20)
       end
 
       it 'returns the viewport height when the interface does not fit the ' \
@@ -130,11 +127,8 @@ module Vedeu
       end
 
       it 'returns the origin for the interface' do
-        console = IO.console
-        console.stub :winsize, [25, 80] do
-          geometry = Geometry.new({ width: 5, height: 5, centred: true })
-          geometry.origin.must_equal("\e[10;38H")
-        end
+        geometry = Geometry.new({ width: 5, height: 5, centred: true })
+        geometry.origin.must_equal("\e[10;38H")
       end
 
       it 'returns the line position relative to the origin' do

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

@@ -4,13 +4,15 @@ module Vedeu
 
   describe Key do
 
-    let(:input)  { '' }
-    let(:output) { proc { :output } }
+    let(:described) { Key.new(input, output) }
+    let(:input)     { '' }
+    let(:output)    { Proc.new { :output } }
 
     describe '#initialize' do
-      it 'returns a new instance of Key' do
-        Key.new(input, output).must_be_instance_of(Key)
-      end
+      it { return_type_for(described, Key) }
+      it { assigns(described, '@input', input) }
+
+      it { skip; assigns(described, '@output', output) }
     end
 
     describe '#input' do

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

@@ -3,6 +3,8 @@ require 'test_helper'
 module Vedeu
 
   describe Line do
+
+    let(:described)  { Line.new(attributes) }
     let(:line)       { Line.new(attributes) }
     let(:attributes) {
       {
@@ -27,31 +29,29 @@ module Vedeu
     }
 
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        Line.new(attributes).must_be_instance_of(Line)
-      end
+      it { return_type_for(described, Line) }
+      it { assigns(described, '@attributes', attributes) }
+      it { assigns(described, '@parent', nil) }
     end
 
     describe '#attributes' do
       it 'returns the attributes' do
-        line.attributes.must_equal(attributes)
+        described.attributes.must_equal(attributes)
       end
     end
 
     describe '#chars' do
-      it 'returns an Array' do
-        line.chars.must_be_instance_of(Array)
-      end
+      it { return_type_for(described.chars, Array) }
 
       context 'when there is no content' do
-        before { line.stubs(:size).returns(0) }
+        before { described.stubs(:size).returns(0) }
 
-        it { line.chars.must_equal([]) }
+        it { described.chars.must_equal([]) }
       end
 
       context 'when there is content' do
         it 'returns an Array' do
-          line.chars.must_equal(
+          described.chars.must_equal(
             [
               "\e[38;2;255;0;0mS", "\e[38;2;255;0;0mo", "\e[38;2;255;0;0mm",
               "\e[38;2;255;0;0me", "\e[38;2;255;0;0mt", "\e[38;2;255;0;0mh",
@@ -90,9 +90,7 @@ module Vedeu
     end
 
     describe '#size' do
-      it 'returns a Fixnum' do
-        line.size.must_be_instance_of(Fixnum)
-      end
+      it { return_type_for(described.size, Fixnum) }
 
       it 'returns the size of the line' do
         line.size.must_equal(53)
@@ -100,9 +98,7 @@ module Vedeu
     end
 
     describe '#streams' do
-      it 'has a streams attribute' do
-        line.streams.must_be_instance_of(Array)
-      end
+      it { return_type_for(described.streams, Array) }
     end
 
     describe '#to_s' do

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

@@ -3,6 +3,18 @@ require 'test_helper'
 module Vedeu
 
   describe Stream do
+
+    let(:described) { Stream.new(attributes) }
+    let(:attributes) {
+      {
+        colour: colour,
+        parent: parent,
+        text:  text,
+        style: style,
+        width: width,
+        align: align
+      }
+    }
     let(:stream) {
       Stream.new({
         colour: colour,
@@ -26,10 +38,12 @@ module Vedeu
     let(:width)  { 9 }
 
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        attributes = {}
-        Stream.new(attributes).must_be_instance_of(Stream)
-      end
+      it { described.must_be_instance_of(Stream) }
+      it { assigns(described, '@attributes', attributes) }
+      it { assigns(described, '@align', align) }
+      it { assigns(described, '@text', text) }
+      it { assigns(described, '@width', width) }
+      it { assigns(described, '@parent', parent) }
     end
 
     describe '#chars' do
@@ -43,9 +57,7 @@ module Vedeu
         }
       }
 
-      it 'returns an Array' do
-        stream.chars.must_be_instance_of(Array)
-      end
+      it { return_type_for(described.chars, Array) }
 
       context 'when there is content' do
         it 'returns a collection of strings containing escape sequences and ' \
@@ -109,9 +121,7 @@ module Vedeu
     end
 
     describe '#size' do
-      it 'returns a Fixnum' do
-        stream.size.must_be_instance_of(Fixnum)
-      end
+      it { return_type_for(described.size, Fixnum) }
 
       it 'returns the size of the stream' do
         stream.size.must_equal(9)

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

@@ -3,25 +3,24 @@ require 'test_helper'
 module Vedeu
 
   describe Style do
-    describe '#initialize' do
-      it 'returns an instance of itself' do
-        values = ''
 
-        Style.new(values).must_be_instance_of(Style)
-      end
+    let(:described) { Style.new(values) }
+    let(:values)    { ['bold'] }
+
+    describe '#initialize' do
+      it { described.must_be_instance_of(Style) }
+      it { assigns(described, '@values', values) }
     end
 
     describe '#attributes' do
       it 'returns an attributes hash for this instance' do
-        Style.new(['bold']).attributes.must_equal(
-          {
-            style: ['bold']
-          }
-        )
+        described.attributes.must_equal({ style: ['bold'] })
       end
     end
 
     describe '#to_s' do
+      it { return_type_for(described.to_s, String) }
+
       describe 'for a single style' do
         let(:values) { 'normal' }
 

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

@@ -3,6 +3,8 @@ require 'test_helper'
 module Vedeu
 
   describe Compositor do
+
+    let(:described) { Compositor.new(interface, buffer) }
     let(:interface) {
       {
         name: 'indium'
@@ -18,31 +20,14 @@ module Vedeu
     end
 
     describe '#initialize' do
-      subject { Compositor.new(interface, buffer) }
-
-      it 'returns an instance of Compositor' do
-        subject.must_be_instance_of(Compositor)
-      end
-
-      it 'assigns the interface' do
-        subject.instance_variable_get("@interface").must_equal(interface)
-      end
-
-      it 'assigns the buffer' do
-        subject.instance_variable_get("@buffer").must_equal(buffer)
-      end
+      it { return_type_for(described, Compositor) }
+      it { assigns(described, '@interface', interface) }
+      it { assigns(described, '@buffer', buffer) }
     end
 
     describe '#compose' do
-      subject { Compositor.new(interface, buffer).compose }
-
-      it 'returns an Array' do
-        subject.must_be_instance_of(Array)
-      end
-
-      it 'returns the updated interface attributes' do
-        subject.must_equal([{}])
-      end
+      it { return_type_for(described.compose, Array) }
+      it { return_value_for(described.compose, [{}]) }
     end
 
   end # Compositor