vedeu 0.2.0 → 0.2.1

data/test/lib/vedeu/configuration_test.rb

@@ -115,6 +115,12 @@ module Vedeu
             debug:         false,
             interactive:   true,
             once:          false,
+            system_keys:   {
+              exit:        "q",
+              focus_next:  :tab,
+              focus_prev:  :shift_tab,
+              mode_switch: :escape
+            },
             terminal_mode: :raw,
             trace:         false
           }
@@ -131,6 +137,12 @@ module Vedeu
             once: true,
             colour_mode: 16777216,
             debug: false,
+            system_keys:   {
+              exit:        "q",
+              focus_next:  :tab,
+              focus_prev:  :shift_tab,
+              mode_switch: :escape
+            },
             terminal_mode: :raw,
             trace: false
           }

data/test/lib/vedeu/models/attributes/coercions_test.rb

@@ -9,7 +9,6 @@ module Vedeu
     def initialize(attributes = {})
       @attributes = attributes
       @name       = attributes[:name]
-      @parent     = attributes[:parent]
     end
   end
 
@@ -30,7 +29,7 @@ module Vedeu
       it 'returns a collection of models when a single hash' do
         coerced = TestClass.coercer({ :name => 'test1' })
         coerced.must_be_instance_of(Array)
-        coerced.first.attributes.must_equal({ name: "test1", parent: nil })
+        coerced.first.attributes.must_equal({ name: "test1" })
       end
 
       it 'returns a collection of models when multiple hashes' do
@@ -39,14 +38,14 @@ module Vedeu
         ])
         coerced.size.must_equal(2)
         coerced.map(&:attributes).must_equal(
-          [{ name: "test1", parent: nil }, { name: "test2", parent: nil }]
+          [{ name: "test1" }, { name: "test2" }]
         )
       end
 
       it 'returns a collection of models when a single array' do
         coerced = TestClass.coercer([{ :name => 'test3' }])
         coerced.size.must_equal(1)
-        coerced.first.attributes.must_equal({ name: "test3", parent: nil })
+        coerced.first.attributes.must_equal({ name: "test3" })
       end
     end
   end

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

@@ -95,48 +95,5 @@ module Vedeu
       end
     end
 
-    describe '#to_s' do
-      it 'returns an string' do
-        Interface.new({
-          name:   '#to_s',
-          lines:  [],
-          colour: {
-            foreground: '#ff0000',
-            background: '#000000'
-          },
-          geometry: {
-            width:  9,
-            height: 3
-          }
-        }).to_s.must_equal(
-          "\e[38;2;255;0;0m\e[48;2;0;0;0m" \
-          "\e[1;1H         \e[1;1H" \
-          "\e[2;1H         \e[2;1H" \
-          "\e[3;1H         \e[3;1H\e[?25h"
-        )
-      end
-    end
-
-    describe '#clear' do
-      it 'delegates to the Clear class to return an empty interface' do
-        Interface.new({
-          name:   '#to_s',
-          lines:  [],
-          colour: {
-            foreground: '#ff0000',
-            background: '#000000'
-          },
-          geometry: {
-            width:  9,
-            height: 3
-          }
-        }).clear.must_equal(
-          "\e[38;2;255;0;0m\e[48;2;0;0;0m" \
-          "\e[1;1H         \e[1;1H" \
-          "\e[2;1H         \e[2;1H" \
-          "\e[3;1H         \e[3;1H"
-        )
-      end
-    end
   end
 end

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

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module Vedeu
+  describe Keymap do
+
+    describe '.define' do
+      it '' do
+        skip
+      end
+    end
+
+    describe '#initialize' do
+      it 'returns an instance of itself' do
+        Keymap.new.must_be_instance_of(Keymap)
+      end
+    end
+
+  end
+end

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

@@ -10,6 +10,16 @@ module Vedeu
       end
     end
 
+    describe '#attributes' do
+      it 'returns an attributes hash for this instance' do
+        Style.new(['bold']).attributes.must_equal(
+          {
+            style: ['bold']
+          }
+        )
+      end
+    end
+
     describe '#to_s' do
       describe 'for a single style' do
         let(:values) { 'normal' }

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

@@ -2,18 +2,6 @@ require 'test_helper'
 
 module Vedeu
   describe Refresh do
-    describe '.add_interface' do
-      it 'returns false when provided with no attributes' do
-        Refresh.add_interface({}).must_equal(false)
-      end
-    end
-
-    describe '.add_group' do
-      it 'returns false when provided with no attributes' do
-        Refresh.add_group({}).must_equal(false)
-      end
-    end
-
     describe '.all' do
       it 'returns an empty collection when there are no registered ' \
          'interfaces' do

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

@@ -131,6 +131,57 @@ module Vedeu
         )
       end
 
+      it 'returns to using the presentation attributes of the line after a ' \
+         'stream finishes' do
+        Vedeu.interface 'oxygen' do
+          width 40
+          height 2
+        end
+
+        class OxygenView < Vedeu::View
+          def render
+            Vedeu.view 'oxygen' do
+              line do
+                colour background: '#000000', foreground: '#ffffff'
+                stream do
+                  text 'the grass is '
+                end
+                stream do
+                  colour foreground: '#00ff00'
+                  text 'green'
+                end
+                stream do
+                  text ' and the sky is '
+                end
+                stream do
+                  colour foreground: '#0000ff'
+                  text 'blue'
+                end
+                stream do
+                  text '.'
+                end
+              end
+            end
+          end
+        end
+
+        IO.console.stub(:print, nil) do
+          OxygenView.render
+
+          Compositor.render('oxygen').must_equal([
+            "\e[1;1H                                        \e[1;1H" \
+            "\e[2;1H                                        \e[2;1H" \
+            "\e[1;1H\e[38;2;255;255;255m\e[48;2;0;0;0m" \
+              "the grass is \e[38;2;255;255;255m\e[48;2;0;0;0m" \
+              "\e[38;2;0;255;0mgreen\e[38;2;255;255;255m\e[48;2;0;0;0m" \
+              " and the sky is \e[38;2;255;255;255m\e[48;2;0;0;0m" \
+              "\e[38;2;0;0;255mblue\e[38;2;255;255;255m\e[48;2;0;0;0m" \
+              ".\e[38;2;255;255;255m\e[48;2;0;0;0m" \
+            "\e[?25h"
+          ])
+        end
+      end
+
     end
   end
 end

data/test/lib/vedeu/repositories/buffers_test.rb

@@ -3,45 +3,72 @@ require 'test_helper'
 module Vedeu
   describe Buffers do
 
-    describe '.create' do
-    end
-
     describe '.add' do
-    end
+      before { Buffers.reset }
 
-    describe '.find' do
-      context 'when the buffer does not exist by this name' do
+      it 'returns the name of the buffer added to storage' do
+        Buffers.add({ name: 'molybdenum' }).must_equal('molybdenum')
       end
 
-      context 'when the buffer can be found by name' do
+      context 'when the buffer is already registered' do
+        it 'retrieves the buffer in storage, and adds the attributes to the ' \
+           'back buffer, preserving the front which may already have content' do
+          skip
+        end
+      end
+
+      context 'when the buffer was not registered' do
+        it 'stores a new buffer by name, and adds the attributes to the back ' \
+           'buffer' do
+          skip
+        end
       end
     end
 
-    describe '.latest' do
+    describe '.find' do
       context 'when the buffer does not exist by this name' do
+        it '' do
+          skip
+        end
       end
 
       context 'when the buffer can be found by name' do
+        it '' do
+          skip
+        end
       end
     end
 
-    describe '.content' do
+    describe '.latest' do
       context 'when the buffer does not exist by this name' do
+        it '' do
+          skip
+        end
       end
 
       context 'when the buffer can be found by name' do
+        it '' do
+          skip
+        end
       end
     end
 
-    describe '.swap_buffers' do
-      context 'when the buffer does not exist by this name' do
+    describe '.registered' do
+      it '' do
+        skip
       end
+    end
 
-      context 'when the buffer can be found by name' do
+    describe '.registered>' do
+      it '' do
+        skip
       end
     end
 
     describe '.reset' do
+      it '' do
+          skip
+        end
     end
 
   end

data/test/lib/vedeu/repositories/events_test.rb

@@ -37,6 +37,12 @@ module Vedeu
       end
     end
 
+    describe '#registered?' do
+      it '' do
+        skip
+      end
+    end
+
     describe '#trigger' do
       it 'returns a collection containing the event when the event is ' \
          'pre-registered' do

data/test/lib/vedeu/repositories/focus_test.rb

@@ -70,5 +70,17 @@ module Vedeu
         Focus.registered.must_equal(['thallium', 'lead', 'bismuth'])
       end
     end
+
+    describe '.registered?' do
+      it '' do
+        skip
+      end
+    end
+
+    describe '.reset' do
+      it '' do
+        skip
+      end
+    end
   end
 end

data/test/lib/vedeu/repositories/keymap_validator_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+module Vedeu
+  describe KeymapValidator do
+    let(:storage)   {
+      {
+        'dubnium' => {
+          'a' => proc { :do_something }
+        },
+        '_global_keymap_' => {
+          'g' => proc { :do_something }
+        }
+      }
+    }
+    let(:key)       { 'a' }
+    let(:interface) { 'dubnium' }
+
+    describe '.check' do
+      context 'when already in use as a system key' do
+        it 'returns false with a message' do
+          result = KeymapValidator.check(storage, :shift_tab, interface)
+          result.must_include(false)
+          result.last.must_match(/by the system/)
+        end
+      end
+
+      context 'when already in use as a global key' do
+        it 'returns false with a message' do
+          result = KeymapValidator.check(storage, 'g', interface)
+          result.must_include(false)
+          result.last.must_match(/as a global key/)
+        end
+      end
+
+      context 'when already in use by the interface' do
+        it 'returns false with a message' do
+          result = KeymapValidator.check(storage, 'a', interface)
+          result.must_include(false)
+          result.last.must_match(/by this interface/)
+        end
+      end
+
+      context 'when attempting to register a global key which is already in ' \
+              'use by an interface' do
+        it 'returns false with a message' do
+          result = KeymapValidator.check(storage, 'a', '')
+          result.must_include(false)
+          result.last.must_match(/therefore cannot be global/)
+        end
+      end
+
+      context 'when valid as a global key' do
+        it 'returns true with a message' do
+          result = KeymapValidator.check(storage, 'h', '')
+          result.must_include(true)
+          result.last.must_match(/can be registered/)
+        end
+      end
+
+      context 'when valid as an interface key' do
+        it 'returns true with a message' do
+          result = KeymapValidator.check(storage, 'b', 'dubnium')
+          result.must_include(true)
+          result.last.must_match(/can be registered/)
+        end
+      end
+    end
+
+    describe '#initialize' do
+      it 'returns an instance of itself' do
+        storage   = {}
+        key       = ''
+        interface = ''
+
+        KeymapValidator.new(storage, key, interface)
+          .must_be_instance_of(KeymapValidator)
+      end
+    end
+
+  end
+end

data/test/lib/vedeu/repositories/keymaps_test.rb

@@ -0,0 +1,254 @@
+require 'test_helper'
+
+module Vedeu
+  describe Keymaps do
+
+    describe '#add' do
+      before { Keymaps.reset }
+
+      it 'returns false when there are no keys defined' do
+        attributes = {}
+
+        Keymaps.add(attributes).must_equal(false)
+      end
+
+      it 'returns true when the key was registered with keymap storage' do
+        attributes = { interfaces: ['gold'], keys: [{ 'a' => proc { :gold } }] }
+
+        Keymaps.add(attributes).must_equal(true)
+      end
+    end
+
+    describe '#all' do
+      before { Keymaps.reset }
+
+      it 'returns all stored keymaps' do
+        Keymaps.all.must_equal({ '_global_keymap_' => {} })
+      end
+    end
+
+    describe '#find' do
+      let(:attributes) {
+        {
+          interfaces: ['flerovium'],
+          keys: [{ key: 'u', action: proc { :some_action } }]
+        }
+      }
+
+      before do
+        Keymaps.reset
+        Keymaps.add(attributes)
+      end
+
+      it 'returns false when the named keymap cannot be found' do
+        Keymaps.find('vanadium').must_equal({})
+      end
+
+      it 'returns the keymap when the named keymap was found' do
+        Keymaps.find('flerovium').wont_be_empty
+      end
+    end
+
+    describe '#global_key?' do
+      before do
+        Keymaps.reset
+        Keymaps.stubs(:global_keys).returns(['i', 'j'])
+      end
+
+      it 'returns false when the key is not registered as a global key' do
+        Keymaps.global_key?('h').must_equal(false)
+      end
+
+      it 'returns true when the key is registered as a global key' do
+        Keymaps.global_key?('j').must_equal(true)
+      end
+    end
+
+    describe '#global_keys' do
+      let(:attributes) {
+        {
+          keys: [
+            {
+              key: 'a', action: proc { :action_a }
+            },{
+              key: 'b', action: proc { :action_b }
+            },{
+              key: 'c', action: proc { :action_c }
+            }
+          ]
+        }
+      }
+
+      before do
+        Keymaps.reset
+        Keymaps.add(attributes)
+      end
+
+      it 'returns the defined global keys' do
+        Keymaps.global_keys.must_equal(['a', 'b', 'c'])
+      end
+    end
+
+    describe '#interface_key?' do
+      before do
+        Keymaps.reset
+        Keymaps.stubs(:interface_keys).returns(['g', 'h'])
+      end
+
+      it 'returns false when the key is not registered with an interface' do
+        Keymaps.interface_key?('f').must_equal(false)
+      end
+
+      it 'returns true when the key is registered with an interface' do
+        Keymaps.interface_key?('g').must_equal(true)
+      end
+
+      context 'when the interface argument is provided' do
+        before do
+          Keymaps.stubs(:find).returns({ 'j' => proc { :some_action } })
+        end
+
+        it 'return false when the key is not registered with the specified ' \
+           'interface' do
+          Keymaps.interface_key?('k', 'cadmium').must_equal(false)
+        end
+
+        it 'return true when the key is registered with the specified ' \
+           'interface' do
+          Keymaps.interface_key?('j', 'cadmium').must_equal(true)
+        end
+      end
+    end
+
+    describe '#interface_keys' do
+      let(:rhodium_attributes) {
+        {
+          interfaces: ['rhodium'],
+          keys: [
+            {
+              key: 'd', action: proc { :action_d }
+            },{
+              key: 'e', action: proc { :action_e }
+            }
+          ]
+        }
+      }
+      let(:magnesium_attributes) {
+        {
+          interfaces: ['magnesium'],
+          keys: [
+            {
+              key: 'e', action: proc { :action_e }
+            },{
+              key: 'f', action: proc { :action_g }
+            }
+          ]
+        }
+      }
+
+      before do
+        Keymaps.reset
+        Keymaps.add(rhodium_attributes)
+        Keymaps.add(magnesium_attributes)
+      end
+
+      it 'returns the defined keys for all interfaces' do
+        Keymaps.interface_keys.must_equal(['d', 'e', 'f'])
+      end
+    end
+
+    describe '#registered' do
+      before { Keymaps.reset }
+
+      it 'returns a collection of the interface names of all registered ' \
+      'keymaps' do
+        Keymaps.registered.must_equal(['_global_keymap_'])
+      end
+    end
+
+    describe '#registered?' do
+      it 'returns false when the named keymap is not registered' do
+        Keymaps.registered?('vanadium').must_equal(false)
+      end
+
+      it 'returns true when the named keymap is registered' do
+        Keymaps.registered?('_global_keymap_').must_equal(true)
+      end
+    end
+
+    describe '#reset' do
+      it 'removes all stored keymaps' do
+        Keymaps.reset.must_equal({ '_global_keymap_' => {} })
+      end
+    end
+
+    describe '#system_key?' do
+      it 'returns false when the key is not registered as a system key' do
+        Keymaps.system_key?('r').must_equal(false)
+      end
+
+      it 'returns true when the key is registered as a system key' do
+        Keymaps.system_key?('q').must_equal(true)
+      end
+    end
+
+    describe '#system_keys' do
+      it 'returns the defined system keys' do
+        Keymaps.system_keys.must_equal(['q', :tab, :shift_tab, :escape])
+      end
+    end
+
+    describe '#use' do
+      let(:meitnerium_attributes) {
+        {
+          interfaces: ['meitnerium'],
+          keys: [{
+            key: 'm', action: proc { :key_m_pressed }
+          }]
+        }
+      }
+      let(:global_attributes) {
+        {
+          keys: [{
+            key: 'o', action: proc { :key_o_pressed }
+          }]
+        }
+      }
+
+      before do
+        Keymaps.reset
+        Keymaps.add(meitnerium_attributes)
+        Keymaps.add(global_attributes)
+        Vedeu::Focus.stubs(:current).returns('meitnerium')
+        Vedeu::Configuration.stubs(:system_keys).returns({ :key_p_pressed => 'p' })
+        Vedeu.stubs(:trigger).returns(:system_key_p_pressed)
+      end
+
+      context 'when not registered' do
+        it 'returns false' do
+          Keymaps.use('l').must_equal(false)
+        end
+      end
+
+      context 'when registered as an interface key and the interface is in ' \
+              'focus' do
+        it 'returns the result of the keypress' do
+          Keymaps.use('m').must_equal(:key_m_pressed)
+        end
+      end
+
+      context 'when registered as a global key' do
+        it 'returns the result of the keypress' do
+          Keymaps.use('o').must_equal(:key_o_pressed)
+        end
+      end
+
+      context 'when registered as a system key' do
+        it 'returns the result of the keypress' do
+          Keymaps.use('p').must_equal(:system_key_p_pressed)
+        end
+      end
+    end
+
+  end
+end