vedeu 0.0.33 → 0.0.34

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

@@ -20,26 +20,6 @@ module Vedeu
       end
     end
 
-    describe '.enqueue' do
-      it 'returns a collection of interfaces' do
-        Composition.enqueue({
-          interfaces: [
-            { name: 'enq1', width: 5, height: 5, lines: { streams: { text: 'Composition.enqueue 1' } } },
-            { name: 'enq2', width: 5, height: 5, lines: { streams: { text: 'Composition.enqueue 2' } } }
-          ]
-        }).interfaces.first.must_be_instance_of(Interface)
-      end
-
-      it 'enqueues the interfaces for rendering' do
-        Composition.enqueue({
-          interfaces: [
-            { name: 'enq1', width: 5, height: 5, lines: { streams: { text: 'Composition.enqueue 3' } } },
-            { name: 'enq2', width: 5, height: 5, lines: { streams: { text: 'Composition.enqueue 4' } } }
-          ]
-        }).interfaces.first.enqueued?.must_equal(true)
-      end
-    end
-
     describe '#to_json' do
       it 'returns the model as JSON' do
         attributes = {
@@ -67,9 +47,9 @@ module Vedeu
         attributes = JSON.load(json, nil, symbolize_names: true)
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3HSome text..."
         )
       end
@@ -80,9 +60,9 @@ module Vedeu
         attributes = JSON.load(json, nil, symbolize_names: true)
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3HSome text... more text..."
         )
       end
@@ -93,9 +73,9 @@ module Vedeu
         attributes = JSON.load(json, nil, symbolize_names: true)
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3HSome text..." \
           "\e[4;3HSome text..."
         )
@@ -107,9 +87,9 @@ module Vedeu
         attributes = JSON.load(json, nil, symbolize_names: true)
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3HSome text... more text..." \
           "\e[4;3HSome text... more text..."
         )
@@ -121,9 +101,9 @@ module Vedeu
         InterfaceRepository.create({ name: 'int1_lin2_str3_styles', y: 3, x: 3, width: 10, height: 3 })
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3H\e[38;5;16m\e[48;5;21m\e[24m\e[21m\e[27m\e[4mSome text...\e[38;5;226m\e[48;5;46m\e[24m\e[21m\e[27m \e[38;5;231m\e[48;5;201m\e[1mmore text..."
         )
       end
@@ -135,13 +115,13 @@ module Vedeu
         attributes = JSON.load(json, nil, symbolize_names: true)
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3HSome text..." \
-          "\e[6;6H          \e[6;6H" \
-          "\e[7;6H          \e[7;6H" \
-          "\e[8;6H          \e[8;6H" \
+          "\e[6;6H          " \
+          "\e[7;6H          " \
+          "\e[8;6H          " \
           "\e[6;6HSome text..."
         )
       end
@@ -153,13 +133,13 @@ module Vedeu
         attributes = JSON.load(json, nil, symbolize_names: true)
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3HSome text... more text..." \
-          "\e[6;6H          \e[6;6H" \
-          "\e[7;6H          \e[7;6H" \
-          "\e[8;6H          \e[8;6H" \
+          "\e[6;6H          " \
+          "\e[7;6H          " \
+          "\e[8;6H          " \
           "\e[6;6HSome text... more text..."
         )
       end
@@ -171,14 +151,14 @@ module Vedeu
         attributes = JSON.load(json, nil, symbolize_names: true)
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3HSome text..." \
           "\e[4;3HSome text..." \
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3HSome text..." \
           "\e[4;3HSome text..."
         )
@@ -191,14 +171,14 @@ module Vedeu
         attributes = JSON.load(json, nil, symbolize_names: true)
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3HSome text... more text..." \
           "\e[4;3HSome text... more text..." \
-          "\e[6;6H          \e[6;6H" \
-          "\e[7;6H          \e[7;6H" \
-          "\e[8;6H          \e[8;6H" \
+          "\e[6;6H          " \
+          "\e[7;6H          " \
+          "\e[8;6H          " \
           "\e[6;6HSome text... more text..." \
           "\e[7;6HSome text... more text..."
         )
@@ -211,14 +191,14 @@ module Vedeu
         attributes = JSON.load(json, nil, symbolize_names: true)
 
         Composition.new(attributes).to_s.must_equal(
-          "\e[3;3H          \e[3;3H" \
-          "\e[4;3H          \e[4;3H" \
-          "\e[5;3H          \e[5;3H" \
+          "\e[3;3H          " \
+          "\e[4;3H          " \
+          "\e[5;3H          " \
           "\e[3;3H\e[38;5;16m\e[48;5;21m\e[24m\e[21m\e[27m\e[4mSome text...\e[38;5;226m\e[48;5;46m\e[24m\e[21m\e[27m \e[38;5;231m\e[48;5;201m\e[1mmore text..." \
           "\e[4;3H\e[38;5;16m\e[48;5;21m\e[24m\e[21m\e[27m\e[4mSome text...\e[38;5;226m\e[48;5;46m\e[24m\e[21m\e[27m \e[38;5;231m\e[48;5;201m\e[1mmore text..." \
-          "\e[6;6H          \e[6;6H" \
-          "\e[7;6H          \e[7;6H" \
-          "\e[8;6H          \e[8;6H" \
+          "\e[6;6H          " \
+          "\e[7;6H          " \
+          "\e[8;6H          " \
           "\e[6;6H\e[38;5;16m\e[48;5;21m\e[24m\e[21m\e[27m\e[4mSome text...\e[38;5;226m\e[48;5;46m\e[24m\e[21m\e[27m \e[38;5;231m\e[48;5;201m\e[1mmore text..." \
           "\e[7;6H\e[38;5;16m\e[48;5;21m\e[24m\e[21m\e[27m\e[4mSome text...\e[38;5;226m\e[48;5;46m\e[24m\e[21m\e[27m \e[38;5;231m\e[48;5;201m\e[1mmore text..."
         )

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

@@ -3,61 +3,78 @@ require_relative '../../../../lib/vedeu/models/interface'
 
 module Vedeu
   describe Interface do
+    let(:interface) {
+      Interface.new({
+        name:  '#initialize',
+        lines: [],
+        colour: {
+          foreground: '#ff0000',
+          background: '#000000'
+        },
+        y: 3,
+        x: 5,
+        z: 2,
+        width: 10,
+        height: 15,
+        current: "\e[1;1H#initialize"
+      })
+    }
+
     it 'has a name attribute' do
-      Interface.new({ name: 'dummy' }).name.must_equal('dummy')
+      interface.name.must_equal('#initialize')
     end
 
     it 'has a lines attribute' do
-      Interface.new({ lines: [] }).lines.must_equal([])
+      interface.lines.must_equal([])
     end
 
     it 'has a colour attribute' do
-      Interface.new({
-        colour: {
-          foreground: '#ff0000',
-          background: '#000000'
-        }
-      }).colour.must_be_instance_of(Colour)
+      interface.colour.must_be_instance_of(Colour)
     end
 
     it 'has a y attribute' do
-      Interface.new({ y: 3 }).y.must_equal(3)
+      interface.y.must_equal(3)
       Interface.new.y.must_equal(1)
     end
 
     it 'has an x attribute' do
-      Interface.new({ x: 5 }).x.must_equal(5)
+      interface.x.must_equal(5)
       Interface.new.x.must_equal(1)
     end
 
     it 'has a z attribute' do
-      Interface.new({ z: 2 }).z.must_equal(2)
+      interface.z.must_equal(2)
       Interface.new.z.must_equal(1)
     end
 
     it 'has a width attribute' do
-      Interface.new({ width: 10 }).width.must_equal(10)
+      interface.width.must_equal(10)
     end
 
     it 'has a height attribute' do
-      Interface.new({ height: 15 }).height.must_equal(15)
+      interface.height.must_equal(15)
     end
 
     it 'has a current attribute' do
-      Interface.new({ current: '' }).current.must_equal('')
+      interface.current.must_equal("\e[1;1H#initialize")
     end
 
     it 'has a cursor attribute' do
-      Interface.new({ cursor: true }).cursor.must_equal(true)
+      interface.cursor.must_equal(true)
       Interface.new({ cursor: false }).cursor.must_equal(false)
-      Interface.new.cursor.must_equal(true)
     end
 
     it 'has a centred attribute' do
-      Interface.new.centred.must_equal(false)
+      interface.centred.must_equal(false)
       Interface.new({ centred: true }).centred.must_equal(true)
     end
 
+    describe '#enqueue' do
+      it 'delegates to the Queue class to enqueue itself' do
+        skip
+      end
+    end
+
     describe '#origin' do
       it 'delegates to the Coordinate class to get the origin' do
         interface = Interface.new({
@@ -86,40 +103,69 @@ module Vedeu
       it 'returns a blank interface when there is no content to display (initial state)' do
         Interface.new(attributes).refresh.must_equal(
           "\e[38;5;196m\e[48;5;16m" \
-          "\e[1;1H   \e[1;1H" \
-          "\e[2;1H   \e[2;1H" \
-          "\e[3;1H   \e[3;1H"
+          "\e[1;1H   " \
+          "\e[2;1H   " \
+          "\e[3;1H   "
         )
       end
 
       it 'returns the fresh content when content is queued up to be displayed' do
-        interface = Interface.new(attributes).enqueue(
-          "\e[38;5;196m\e[48;5;16m" \
-          "\e[1;1HContent\e[1;1H" \
-          "\e[2;1HContent\e[2;1H" \
-          "\e[3;1HContent\e[3;1H"
-        )
+        attributes = {
+          name:   '#refresh',
+          lines:  [
+            { streams: '#refresh' },
+            { streams: '#refresh' },
+            { streams: '#refresh' }
+          ],
+          colour: {
+            foreground: '#ff0000',
+            background: '#000000'
+          },
+          width:  8,
+          height: 3
+        }
+        interface = Interface.new(attributes)
+        interface.enqueue
 
         interface.refresh.must_equal(
           "\e[38;5;196m\e[48;5;16m" \
-          "\e[1;1HContent\e[1;1H" \
-          "\e[2;1HContent\e[2;1H" \
-          "\e[3;1HContent\e[3;1H"
+          "\e[1;1H        " \
+          "\e[2;1H        " \
+          "\e[3;1H        " \
+          "\e[1;1H#refresh" \
+          "\e[2;1H#refresh" \
+          "\e[3;1H#refresh"
         )
       end
 
       it 'returns the previously shown content when there is stale content from last run' do
+        attributes = {
+          name:   '#refresh',
+          lines:  [],
+          colour: {
+            foreground: '#ff0000',
+            background: '#000000'
+          },
+          width:  8,
+          height: 3
+        }
         interface = Interface.new(attributes)
         interface.current = "\e[38;5;196m\e[48;5;16m" \
-                            "\e[1;1HOld\e[1;1H" \
-                            "\e[2;1HContent\e[2;1H" \
-                            "\e[3;1Here\e[3;1H"
+                            "\e[1;1H        " \
+                            "\e[2;1H        " \
+                            "\e[3;1H        " \
+                            "\e[1;1H#refresh" \
+                            "\e[2;1H#refresh" \
+                            "\e[3;1H#refresh"
 
         interface.refresh.must_equal(
           "\e[38;5;196m\e[48;5;16m" \
-          "\e[1;1HOld\e[1;1H" \
-          "\e[2;1HContent\e[2;1H" \
-          "\e[3;1Here\e[3;1H"
+          "\e[1;1H        " \
+          "\e[2;1H        " \
+          "\e[3;1H        " \
+          "\e[1;1H#refresh" \
+          "\e[2;1H#refresh" \
+          "\e[3;1H#refresh"
         )
       end
     end
@@ -137,9 +183,9 @@ module Vedeu
           height: 3
         }).to_s.must_equal(
           "\e[38;5;196m\e[48;5;16m" \
-          "\e[1;1H   \e[1;1H" \
-          "\e[2;1H   \e[2;1H" \
-          "\e[3;1H   \e[3;1H"
+          "\e[1;1H   " \
+          "\e[2;1H   " \
+          "\e[3;1H   "
         )
       end
     end

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

@@ -3,36 +3,42 @@ require_relative '../../../../lib/vedeu/models/line'
 
 module Vedeu
   describe Line do
-    it 'has a colour attribute' do
+    let(:line) {
       Line.new({
-        colour: { foreground: '#ff0000', background: '#000000' }
-      }).colour.must_be_instance_of(Colour)
+        colour: {
+          foreground: '#ff0000',
+          background: '#000000'
+        },
+        model:   {},
+        streams: [],
+        style:   'normal'
+      })
+    }
+
+    it 'has a colour attribute' do
+      line.colour.must_be_instance_of(Colour)
     end
 
     it 'has a model attribute' do
-      Line.new(model: {}).model.must_be_instance_of(Hash)
+      line.model.must_be_instance_of(Hash)
     end
 
     it 'has a streams attribute' do
-      Line.new(streams: []).streams.must_equal([])
+      line.streams.must_equal([])
     end
 
     describe '#to_json' do
       it 'returns an String' do
-        Line.new({
-          colour:  { foreground: '#ff0000', background: '#000000' },
-          style:   'normal',
-          streams: [],
-        }).to_json.must_equal("{\"colour\":{\"foreground\":\"#ff0000\",\"background\":\"#000000\"},\"style\":[\"normal\"],\"streams\":[]}")
+        line.to_json.must_equal("{\"colour\":{\"foreground\":\"#ff0000\",\"background\":\"#000000\"},\"style\":[\"normal\"],\"streams\":[]}")
       end
     end
 
     describe '#to_s' do
       it 'returns an String' do
-        Line.new({
-          colour: { foreground: '#ff0000', background: '#000000' },
-          style:  'normal',
-        }).to_s.must_equal("\e[38;5;196m\e[48;5;16m\e[24m\e[21m\e[27m")
+        line.to_s.must_equal(
+          "\e[38;5;196m\e[48;5;16m" \
+          "\e[24m\e[21m\e[27m"
+        )
       end
     end
   end

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

@@ -7,20 +7,24 @@ module Vedeu
   end
 
   describe Presentation do
+    let(:presentation) {
+      TestPresentation.new({
+        colour: {
+          foreground: '#ff0000',
+          background: '#333333'
+        },
+        style: ['bold', 'underline']
+      })
+    }
+
     describe '#colour' do
       it 'returns a Colour instance' do
-        presentation = TestPresentation.new({
-          colour: { foreground: '#ff0000', background: '#333333' }
-        })
         presentation.colour.must_be_instance_of(Colour)
       end
     end
 
     describe '#style' do
       it 'has a style attribute' do
-        presentation = TestPresentation.new({
-          style: ['bold', 'underline']
-        })
         presentation.style.must_equal(['bold', 'underline'])
       end
     end

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

@@ -15,8 +15,8 @@ module Vedeu
           height: 2
         })
         InterfaceRenderer.clear(interface).must_equal(
-          "\e[1;1H     \e[1;1H" \
-          "\e[2;1H     \e[2;1H"
+          "\e[1;1H     " \
+          "\e[2;1H     "
         )
       end
 
@@ -32,8 +32,8 @@ module Vedeu
         })
         InterfaceRenderer.clear(interface).must_equal(
           "\e[38;5;46m\e[48;5;226m" \
-          "\e[1;1H     \e[1;1H" \
-          "\e[2;1H     \e[2;1H"
+          "\e[1;1H     " \
+          "\e[2;1H     "
         )
       end
     end

data/test/lib/vedeu/process/process_test.rb

@@ -42,7 +42,7 @@ module Vedeu
         proc { Process.evaluate }.must_raise(StopIteration)
       end
 
-      it 'returns an Composition when there is a result' do
+      it 'returns a collection of interfaces when there is a result' do
         CommandRepository.reset
         CommandRepository.create({
           name:     'test',
@@ -51,7 +51,10 @@ module Vedeu
         })
         Queue.reset
         Queue.enqueue('t')
-        Process.evaluate.must_be_instance_of(Composition)
+        evaluation = Process.evaluate
+
+        evaluation.must_be_instance_of(Array)
+        evaluation.size.must_equal(1)
       end
 
       it 'returns a NilClass when there is no result' do

data/test/lib/vedeu/repository/interface_repository_test.rb

@@ -3,6 +3,8 @@ require_relative '../../../../lib/vedeu/repository/interface_repository'
 
 module Vedeu
   describe InterfaceRepository do
+    before { InterfaceRepository.reset }
+
     describe '.create' do
       it 'returns an Interface' do
         InterfaceRepository.create({
@@ -14,19 +16,14 @@ module Vedeu
     end
 
     describe '.find' do
-      it 'returns an Interface when the interface exists' do
-        InterfaceRepository.create({
-          name:   'dummy',
-          width:  5,
-          height: 5
-        })
-        InterfaceRepository.find('dummy')
-          .must_be_instance_of(Interface)
+      it 'returns the interface if it exists' do
+        hydrogen =  InterfaceRepository.create({ name: 'hydrogen' })
+
+        InterfaceRepository.find('hydrogen').must_equal(hydrogen)
       end
 
-      it 'raises an exception when the interface does not exist' do
-        InterfaceRepository.reset
-        proc { InterfaceRepository.find('dummy') }
+      it 'raises an exception if it does not exist' do
+        proc { InterfaceRepository.find('helium') }
           .must_raise(UndefinedInterface)
       end
     end
@@ -43,7 +40,6 @@ module Vedeu
       end
 
       it 'returns a new interface when the interface does not exist' do
-        InterfaceRepository.reset
         InterfaceRepository.update('dummy', { name: 'dumber' }).name
           .must_equal('dumber')
       end
@@ -55,17 +51,33 @@ module Vedeu
       end
 
       it 'returns the collection in order they should be drawn' do
-        InterfaceRepository.reset
         InterfaceRepository.create({
-          name: 'a', width: 5, height: 5, z: 2
-        }).enqueue("a")
+          name:   '.refresh_1',
+          width:  1,
+          height: 1,
+          z:      3,
+          lines:  'alpha'
+        }).enqueue
         InterfaceRepository.create({
-          name: 'b', width: 5, height: 5, z: 1
-        }).enqueue("b")
+          name:   '.refresh_2',
+          width:  1,
+          height: 1,
+          z:      1,
+          lines:  'beta'
+        }).enqueue
         InterfaceRepository.create({
-          name: 'c', width: 5, height: 5, z: 3
-        }).enqueue("c")
-        InterfaceRepository.refresh.must_equal(['b', 'a', 'c'])
+          name:   '.refresh_3',
+          width:  1,
+          height: 1,
+          z:      2,
+          lines:  'gamma'
+        }).enqueue
+
+        InterfaceRepository.refresh.must_equal([
+          "\e[1;1H \e[1;1Hbeta",
+          "\e[1;1H \e[1;1Hgamma",
+          "\e[1;1H \e[1;1Halpha"
+        ])
       end
     end
 

data/test/lib/vedeu/repository/repository_test.rb

@@ -23,13 +23,6 @@ module Vedeu
       end
     end
 
-    describe '#find' do
-      it 'returns a Dummy' do
-        dummy = DummyRepository.create(Dummy.new)
-        DummyRepository.find(dummy.name).must_be_instance_of(Dummy)
-      end
-    end
-
     describe '#all' do
       it 'returns all the stored items' do
         DummyRepository.all.must_be_instance_of(Array)
@@ -37,10 +30,15 @@ module Vedeu
     end
 
     describe '#query' do
-      it 'returns a Dummy' do
-        dummy = DummyRepository.create(Dummy.new)
-        DummyRepository.query(Dummy, :name, 'dummy')
-          .must_be_instance_of(Dummy)
+      it 'delegates to the adaptor' do
+        dumb = Dummy.new
+        DummyRepository.create(dumb)
+
+        result = DummyRepository.query(Dummy, :name, 'dummy')
+        result.must_equal(dumb)
+
+        result = DummyRepository.query(Dummy, :name, 'dumber')
+        result.must_equal(false)
       end
     end
 

data/test/lib/vedeu/repository/storage_test.rb

@@ -24,12 +24,6 @@ module Vedeu
       end
     end
 
-    describe '#find' do
-      it 'returns a NilClass' do
-        Storage.new.find(nil, 'dummy').must_be_instance_of(NilClass)
-      end
-    end
-
     describe '#all' do
       it 'returns an Array' do
         Storage.new.all(nil).must_be_instance_of(Array)
@@ -37,9 +31,14 @@ module Vedeu
     end
 
     describe '#query' do
-      it 'returns a FalseClass when the item cannot be found' do
-        Storage.new.query(nil, nil, nil)
-          .must_be_instance_of(FalseClass)
+      it 'returns the item if found, otherwise false' do
+        Record   = Struct.new(:name)
+        storage  = Storage.new
+        hydrogen = storage.create(Record.new('hydrogen'))
+
+        storage.query(Record, :name, nil).must_equal(false)
+        storage.query(Record, :name, 'lithium').must_equal(false)
+        storage.query(Record, :name, 'hydrogen').must_equal(hydrogen)
       end
     end
   end