vedeu 0.6.9 → 0.6.10

data/test/lib/vedeu/runtime/router_test.rb

@@ -13,192 +13,196 @@ module Vedeu
 
   end # SomeController
 
-  describe Router do
+  module Runtime
 
-    let(:described) { Vedeu::Router }
+    describe Router do
 
-    before { described.reset! }
+      let(:described) { Vedeu::Runtime::Router }
 
-    describe '.add_controller' do
-      let(:controller) {}
-      let(:klass) { "SomeController" }
+      before { described.reset! }
 
-      subject { described.add_controller(controller, klass) }
+      describe '.add_controller' do
+        let(:controller) {}
+        let(:klass) { "SomeController" }
 
-      context 'when a name is not given' do
-        it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
-      end
+        subject { described.add_controller(controller, klass) }
 
-      context 'when a name is given' do
-        let(:controller) { :some_controller }
+        context 'when a name is not given' do
+          it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
+        end
 
-        context 'when the controller is registered' do
-          before do
-            described.add_controller(controller, '')
-            described.add_action(controller, :show_basket)
+        context 'when a name is given' do
+          let(:controller) { :some_controller }
+
+          context 'when the controller is registered' do
+            before do
+              described.add_controller(controller, '')
+              described.add_action(controller, :show_basket)
+            end
+            after  { described.reset! }
+
+            it {
+              subject.must_equal({
+                some_controller: {
+                  klass:   'SomeController',
+                  actions: [:show_basket]
+                }
+              })
+            }
           end
-          after  { described.reset! }
-
-          it {
-            subject.must_equal({
-              some_controller: {
-                klass:   'SomeController',
-                actions: [:show_basket]
-              }
-            })
-          }
-        end
 
-        context 'when the controller is not registered' do
-          it {
-            subject.must_equal({
-              some_controller: {
-                klass:   'SomeController',
-                actions: []
-              }
-            })
-          }
+          context 'when the controller is not registered' do
+            it {
+              subject.must_equal({
+                some_controller: {
+                  klass:   'SomeController',
+                  actions: []
+                }
+              })
+            }
+          end
         end
       end
-    end
-
-    describe '.add_action' do
-      let(:controller) {}
-      let(:action)     {}
 
-      subject { described.add_action(controller, action) }
+      describe '.add_action' do
+        let(:controller) {}
+        let(:action)     {}
 
-      context 'when the controller is not given' do
-        let(:action) { :some_action }
+        subject { described.add_action(controller, action) }
 
-        it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
-      end
-
-      context 'when the name is not given' do
-        let(:controller) { :some_controller }
+        context 'when the controller is not given' do
+          let(:action) { :some_action }
 
-        it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
-      end
-
-      context 'when the controller and name is given' do
-        let(:controller) { :some_controller }
-        let(:action) { :some_action }
+          it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
+        end
 
-        context 'when the controller is registered' do
-          before { described.add_controller(controller, 'SomeController') }
-          after  { described.reset! }
+        context 'when the name is not given' do
+          let(:controller) { :some_controller }
 
-          it {
-            subject.must_equal({
-              some_controller: {
-                klass:   'SomeController',
-                actions: [:some_action]
-              }
-            })
-          }
+          it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
         end
 
-        context 'when the controller is not registered' do
-          before { described.reset! }
-
-          it {
-            subject.must_equal({
-              some_controller: {
-                klass:   '',
-                actions: [:some_action]
-              }
-            })
-          }
+        context 'when the controller and name is given' do
+          let(:controller) { :some_controller }
+          let(:action) { :some_action }
+
+          context 'when the controller is registered' do
+            before { described.add_controller(controller, 'SomeController') }
+            after  { described.reset! }
+
+            it {
+              subject.must_equal({
+                some_controller: {
+                  klass:   'SomeController',
+                  actions: [:some_action]
+                }
+              })
+            }
+          end
+
+          context 'when the controller is not registered' do
+            before { described.reset! }
+
+            it {
+              subject.must_equal({
+                some_controller: {
+                  klass:   '',
+                  actions: [:some_action]
+                }
+              })
+            }
+          end
         end
       end
-    end
 
-    describe '.goto' do
-      let(:controller) { :some_controller }
-      let(:action)     { :some_action }
-      let(:args)            {
-        {
-          customer_id: 7,
-          product_id:  88,
+      describe '.goto' do
+        let(:controller) { :some_controller }
+        let(:action)     { :some_action }
+        let(:args)            {
+          {
+            customer_id: 7,
+            product_id:  88,
+          }
         }
-      }
 
-      subject { described.goto(controller, action, **args) }
+        subject { described.goto(controller, action, **args) }
 
-      it { described.must_respond_to(:action) }
+        it { described.must_respond_to(:action) }
 
-      context 'when the controller is registered' do
-        context 'when the controller klass is defined' do
-          before do
-            described.add_controller(controller, 'Vedeu::SomeController')
-            described.add_action(controller, action)
+        context 'when the controller is registered' do
+          context 'when the controller klass is defined' do
+            before do
+              described.add_controller(controller, 'Vedeu::SomeController')
+              described.add_action(controller, action)
+            end
+            after { described.reset! }
+
+            it {
+              subject.must_equal({
+                customer: {
+                  name: 'Gavin Laking',
+                  customer_id: 7
+                },
+                basket: {
+                  product_ids: [88]
+                }
+              })
+            }
           end
-          after { described.reset! }
-
-          it {
-            subject.must_equal({
-              customer: {
-                name: 'Gavin Laking',
-                customer_id: 7
-              },
-              basket: {
-                product_ids: [88]
-              }
-            })
-          }
-        end
 
-        context 'when the action is not defined for this controller' do
-          let(:action) { :undefined_action }
+          context 'when the action is not defined for this controller' do
+            let(:action) { :undefined_action }
+
+            before do
+              described.add_controller(controller, 'Vedeu::SomeController')
+            end
 
-          before do
-            described.add_controller(controller, 'Vedeu::SomeController')
+            it { proc { subject }.must_raise(Vedeu::Error::ActionNotFound) }
           end
 
-          it { proc { subject }.must_raise(Vedeu::Error::ActionNotFound) }
-        end
+          context 'when the controller klass is not defined' do
+            before do
+              described.add_controller(controller, '')
+              described.add_action(controller, action)
+            end
+            after { described.reset! }
 
-        context 'when the controller klass is not defined' do
-          before do
-            described.add_controller(controller, '')
-            described.add_action(controller, action)
+            it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
           end
-          after { described.reset! }
+        end
 
-          it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
+        context 'when the controller is not registered' do
+          it { proc { subject }.must_raise(Vedeu::Error::ControllerNotFound) }
         end
       end
 
-      context 'when the controller is not registered' do
-        it { proc { subject }.must_raise(Vedeu::Error::ControllerNotFound) }
-      end
-    end
+      describe '.registered' do
+        let(:controller) { :some_controller }
 
-    describe '.registered' do
-      let(:controller) { :some_controller }
+        subject { described.registered?(controller) }
 
-      subject { described.registered?(controller) }
+        context 'when the controller is registered' do
+          before { described.add_controller(controller, "SomeController") }
+          after  { described.reset! }
 
-      context 'when the controller is registered' do
-        before { described.add_controller(controller, "SomeController") }
-        after  { described.reset! }
+          it { subject.must_equal(true) }
+        end
 
-        it { subject.must_equal(true) }
+        context 'when the controller is not registered' do
+          it { subject.must_equal(false) }
+        end
       end
 
-      context 'when the controller is not registered' do
-        it { subject.must_equal(false) }
-      end
-    end
+      describe '.reset!' do
+        subject { described.reset! }
 
-    describe '.reset!' do
-      subject { described.reset! }
+        it { subject.must_equal({}) }
 
-      it { subject.must_equal({}) }
+        it { described.must_respond_to(:reset) }
+      end
 
-      it { described.must_respond_to(:reset) }
-    end
+    end # Router
 
-  end # Router
+  end # Runtime
 
 end # Vedeu

data/test/lib/vedeu/terminal/buffer_test.rb

@@ -0,0 +1,307 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Terminal
+
+    describe Buffer do
+
+      let(:described) { Vedeu::Terminal::Buffer }
+      let(:height)    { 2 }
+      let(:width)     { 3 }
+
+      before do
+        Vedeu.stubs(:height).returns(height)
+        Vedeu.stubs(:width).returns(width)
+        Vedeu::Terminal::Buffer.reset
+      end
+
+      describe '#buffer' do
+        let(:expected) {
+          Array.new(height) do |y|
+            Array.new(width) do |x|
+              Vedeu::Models::Cell.new(position: [y + 1, x + 1])
+            end
+          end
+        }
+
+        subject { described.buffer }
+
+        it { subject.must_be_instance_of(Array) }
+        it { described.instance_variable_get('@output').must_equal(expected) }
+        it { subject.must_equal(expected) }
+      end
+
+      describe '#empty_buffer' do
+        let(:expected) {
+          Array.new(height) do |y|
+            Array.new(width) do |x|
+              Vedeu::Models::Cell.new(position: [y + 1, x + 1])
+            end
+          end
+        }
+
+        subject { described.empty_buffer }
+
+        it { subject.must_be_instance_of(Array) }
+        it { subject.must_equal(expected) }
+      end
+
+      # describe '#output' do
+      #   subject { described.output }
+
+      #   context 'when nothing has been written to the buffer' do
+      #     it {
+      #       described.instance_variable_get('@output').must_equal(empty_buffer)
+      #     }
+      #   end
+
+      #   context 'when something has been written to the buffer' do
+      #     let(:expected) {
+      #       exp = empty_buffer
+      #       exp[1][2] = Vedeu::Views::Char.new(value: 'a', position: [1, 2])
+      #       exp
+      #     }
+
+      #     before do
+      #       described.write(Vedeu::Views::Char.new(value: 'a',
+      #                                              position: [1, 2]))
+      #     end
+
+      #     it { described.instance_variable_get('@output').must_equal(expected) }
+      #   end
+      # end
+
+      describe '#render' do
+        let(:ready) { false }
+
+        before { Vedeu.stubs(:ready?).returns(ready) }
+
+        subject { described.render }
+
+        context 'when Vedeu is not ready' do
+          it { subject.must_equal(nil) }
+        end
+
+        context 'when Vedeu is ready' do
+          let(:ready) { true }
+
+          context 'when the buffer is empty' do
+            # it {
+            #   Vedeu.renderers.expects(:render).with(Vedeu::Models::Page)
+            #   subject
+            # }
+          end
+
+          context 'when the buffer is not empty' do
+          end
+        end
+      end
+
+      describe '#reset' do
+        let(:output) {
+          Array.new(height) do |y|
+            Array.new(width) do |x|
+              Vedeu::Models::Cell.new(position: [y + 1, x + 1])
+            end
+          end
+        }
+
+        subject { described.reset }
+
+        it { described.instance_variable_get('@output').must_equal(output) }
+        it { subject.must_be_instance_of(Array) }
+        it { subject.must_equal(output) }
+
+        it { described.must_respond_to(:clear) }
+      end
+
+      describe '#write' do
+        let(:_value) {}
+
+        subject { described.write(_value) }
+
+        # context 'when the value is nil' do
+        #   let(:expected) {
+        #     [
+        #       [
+        #         Vedeu::Models::Cell.new(position: [1, 1]),
+        #         Vedeu::Models::Cell.new(position: [1, 2]),
+        #         Vedeu::Models::Cell.new(position: [1, 3])
+        #       ], [
+        #         Vedeu::Models::Cell.new(position: [2, 1]),
+        #         Vedeu::Models::Cell.new(position: [2, 2]),
+        #         Vedeu::Models::Cell.new(position: [2, 3])
+        #       ]
+        #     ]
+        #   }
+
+        #   it { subject.must_equal(described) }
+        #   it { described.output.must_equal(expected) }
+        # end
+
+        # context 'when the value is not nil' do
+        #   let(:_value)   { Vedeu::Views::Char.new(y: 2, x: 1, value: 'a') }
+        #   let(:expected) {
+
+        #   }
+
+        #   it { subject.must_equal(described) }
+        #   it { described.output.must_equal(expected) }
+        # end
+      end
+
+    end # Buffer
+
+  end # Terminal
+
+end # Vedeu
+
+# require 'test_helper'
+
+# module Vedeu
+
+#   module Buffers
+
+#     describe VirtualBuffer do
+
+#       let(:described) { Vedeu::Buffers::VirtualBuffer }
+#       let(:instance)  { described.new(height, width, renderer) }
+#       let(:height)    { 3 }
+#       let(:width)     { 3 }
+#       let(:renderer)  { Vedeu::Renderers::HTML.new }
+
+#       describe '#initialize' do
+#         it { instance.must_be_instance_of(described) }
+#         it { instance.instance_variable_get('@height').must_equal(3) }
+#         it { instance.instance_variable_get('@width').must_equal(3) }
+#         it { instance.instance_variable_get('@renderer').must_equal(renderer) }
+#       end
+
+#       describe 'accessors' do
+#         it { instance.must_respond_to(:renderer) }
+#         it { instance.must_respond_to(:renderer=) }
+#         it { instance.must_respond_to(:height) }
+#         it { instance.must_respond_to(:width) }
+#       end
+
+#       describe '.output' do
+#         let(:data) {}
+
+#         before do
+#           Vedeu.stubs(:width).returns(3)
+#           Vedeu.stubs(:height).returns(3)
+#         end
+
+#         subject { described.output(data) }
+
+#         it { subject.must_be_instance_of(Array) }
+#       end
+
+#       describe '#cells' do
+#         before do
+#           Vedeu.stubs(:width).returns(3)
+#           Vedeu.stubs(:height).returns(3)
+#         end
+
+#         subject { instance.cells }
+
+#         it { subject.must_be_instance_of(Array) }
+#         it { subject.size.must_equal(3) }
+#         it { subject.flatten.size.must_equal(9) }
+#       end
+
+#       describe '#read' do
+#         subject { instance.read(y, x) }
+
+#         context 'when x is out of bounds' do
+#           let(:y) { 1 }
+#           let(:x) { 5 }
+
+#           it { subject.must_equal([]) }
+#         end
+
+#         context 'when y is out of bounds' do
+#           let(:y) { 5 }
+#           let(:x) { 1 }
+
+#           it { subject.must_equal([]) }
+#         end
+
+#         context 'when both x and y are out of bounds' do
+#           let(:y) { 5 }
+#           let(:x) { 5 }
+
+#           it { subject.must_equal([]) }
+#         end
+
+#         context 'when x and y are in bounds' do
+#           let(:y) { 0 }
+#           let(:x) { 2 }
+
+#           it { subject.must_be_instance_of(Vedeu::Models::Cell) }
+#         end
+#       end
+
+#       describe '#output' do
+#         it { instance.must_respond_to(:output) }
+#       end
+
+#       describe '#render' do
+#         before do
+#           Vedeu.stubs(:width).returns(3)
+#           Vedeu.stubs(:height).returns(3)
+#         end
+
+#         subject { instance.render }
+
+#         it { subject.must_be_instance_of(String) }
+#       end
+
+#       describe '#reset' do
+#         subject { instance.reset }
+
+#         it { subject.must_be_instance_of(Array) }
+
+#         it { instance.must_respond_to(:clear) }
+#       end
+
+#       describe '#write' do
+#         let(:data) { Vedeu::Views::Char.new(value: 'a') }
+
+#         subject { instance.write(y, x, data) }
+
+#         context 'when x is out of bounds' do
+#           let(:y) { 1 }
+#           let(:x) { 5 }
+
+#           it { subject.must_equal(false) }
+#         end
+
+#         context 'when y is out of bounds' do
+#           let(:y) { 5 }
+#           let(:x) { 1 }
+
+#           it { subject.must_equal(false) }
+#         end
+
+#         context 'when both x and y are out of bounds' do
+#           let(:y) { 5 }
+#           let(:x) { 5 }
+
+#           it { subject.must_equal(false) }
+#         end
+
+#         context 'when x and y are in bounds' do
+#           let(:y) { 0 }
+#           let(:x) { 2 }
+
+#           it { subject.must_equal(true) }
+#         end
+#       end
+
+#     end # VirtualBuffer
+
+#   end # Buffers
+
+# end # Vedeu

data/test/support/examples/material_colours_app.rb

@@ -24,9 +24,9 @@ class VedeuMaterialColoursApp
   # Be aware that running an application with debugging enabled will affect
   # performance.
   Vedeu.configure do
-    # debug!
+    debug!
     log '/tmp/vedeu_material_colours_app.log'
-    # renderers Vedeu::Renderers::File.new
+    renderers Vedeu::Renderers::HTML.new(filename: '/tmp/material', timestamp: true)
   end
 
   Vedeu.interface 'main_interface' do

data/test/support/templates/html_renderer.vedeu

@@ -0,0 +1,24 @@
+<html>
+  <head>
+    <style type='text/css'>
+      body {
+        background:#000;
+      }
+      td {
+        border:1px #171717 solid;
+        font-size:12px;
+        font-family:monospace;
+        height:18px;
+        margin:1px;
+        text-align:center;
+        vertical-align:center;
+        width:18px;
+      }
+    </style>
+  </head>
+  <body>
+    <table>
+      <%= @object.html_body -%>
+    </table>
+  </body>
+</html>