vedeu 0.6.7 → 0.6.8

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

@@ -2,102 +2,106 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Keymap do
-
-    let(:described)  { Vedeu::Keymap }
-    let(:instance)   { described.new(attributes) }
-    let(:attributes) {
-      {
-        name: map_name,
-        keys: keys
+  module Input
+
+    describe Keymap do
+
+      let(:described)  { Vedeu::Input::Keymap }
+      let(:instance)   { described.new(attributes) }
+      let(:attributes) {
+        {
+          name: map_name,
+          keys: keys
+        }
       }
-    }
-    let(:map_name)  { 'zirconium' }
-    let(:keys)      { [] }
-    let(:key)       { Vedeu::Key.new('a') { :output } }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@name').must_equal(map_name) }
-      it { instance.instance_variable_get('@keys').must_be_instance_of(Array) }
-      it do
-        instance.instance_variable_get('@repository').must_equal(Vedeu.keymaps)
+      let(:map_name)  { 'zirconium' }
+      let(:keys)      { [] }
+      let(:key)       { Vedeu::Input::Key.new('a') { :output } }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@name').must_equal(map_name) }
+        it { instance.instance_variable_get('@keys').must_be_instance_of(Array) }
+        it do
+          instance.instance_variable_get('@repository').must_equal(Vedeu.keymaps)
+        end
+      end
+
+      describe 'accessors' do
+        it { instance.must_respond_to(:name) }
       end
-    end
 
-    describe 'accessors' do
-      it { instance.must_respond_to(:name) }
-    end
+      describe '#add' do
+        subject { instance.add(key) }
 
-    describe '#add' do
-      subject { instance.add(key) }
+        context 'when the key is already defined' do
+          before do
+            Vedeu.keymaps.reset
+            instance.add(key)
+          end
 
-      context 'when the key is already defined' do
-        before do
-          Vedeu.keymaps.reset
-          instance.add(key)
+          it { subject.must_equal(false) }
         end
 
-        it { subject.must_equal(false) }
+        context 'when the key is not already defined' do
+          it { subject.must_be_instance_of(Vedeu::Input::Keys) }
+        end
       end
 
-      context 'when the key is not already defined' do
-        it { subject.must_be_instance_of(Vedeu::Keys) }
-      end
-    end
+      describe '#key_defined?' do
+        let(:input) { 'a' }
 
-    describe '#key_defined?' do
-      let(:input) { 'a' }
+        subject { instance.key_defined?(input) }
 
-      subject { instance.key_defined?(input) }
+        context 'when the input is defined' do
+          let(:keys) { Vedeu::Input::Keys.new([key]) }
 
-      context 'when the input is defined' do
-        let(:keys) { Vedeu::Keys.new([key]) }
+          it { subject.must_be_instance_of(TrueClass) }
+        end
 
-        it { subject.must_be_instance_of(TrueClass) }
+        context 'when the input is not defined' do
+          it { subject.must_be_instance_of(FalseClass) }
+        end
       end
 
-      context 'when the input is not defined' do
-        it { subject.must_be_instance_of(FalseClass) }
-      end
-    end
+      describe '#use' do
+        let(:input) { 'b' }
 
-    describe '#use' do
-      let(:input) { 'b' }
+        subject { instance.use(input) }
 
-      subject { instance.use(input) }
+        context 'when the input is defined' do
+          let(:key_a) { Vedeu::Input::Key.new('a') { :key_a } }
+          let(:key_b) { Vedeu::Input::Key.new('b') { :key_b } }
+          let(:key_c) { Vedeu::Input::Key.new('c') { :key_c } }
+          let(:keys)  { Vedeu::Input::Keys.new([key_a, key_b, key_c]) }
 
-      context 'when the input is defined' do
-        let(:key_a) { Vedeu::Key.new('a') { :key_a } }
-        let(:key_b) { Vedeu::Key.new('b') { :key_b } }
-        let(:key_c) { Vedeu::Key.new('c') { :key_c } }
-        let(:keys)  { Vedeu::Keys.new([key_a, key_b, key_c]) }
+          it { subject.must_be_instance_of(Array) }
+          it { subject.must_equal([:key_b]) }
+        end
 
-        it { subject.must_be_instance_of(Array) }
-        it { subject.must_equal([:key_b]) }
+        context 'when the input is not defined' do
+          it { subject.must_be_instance_of(FalseClass) }
+        end
       end
 
-      context 'when the input is not defined' do
-        it { subject.must_be_instance_of(FalseClass) }
-      end
-    end
+      describe '#keys' do
+        subject { instance.keys }
 
-    describe '#keys' do
-      subject { instance.keys }
+        it { subject.must_be_instance_of(Vedeu::Input::Keys) }
+      end
 
-      it { subject.must_be_instance_of(Vedeu::Keys) }
-    end
+      describe '#name' do
+        subject { instance.name }
 
-    describe '#name' do
-      subject { instance.name }
+        it { subject.must_be_instance_of(String) }
+      end
 
-      it { subject.must_be_instance_of(String) }
-    end
+      describe '#name=' do
+        it { instance.must_respond_to(:name=) }
+      end
 
-    describe '#name=' do
-      it { instance.must_respond_to(:name=) }
-    end
+    end # Keymap
 
-  end # Keymap
+  end # Input
 
 end # Vedeu

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

@@ -2,12 +2,16 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Keymaps do
+  module Input
 
-    let(:described) { Vedeu::Keymaps }
+    describe Keymaps do
 
-    it { described.must_respond_to(:keymaps) }
+      let(:described) { Vedeu::Input::Keymaps }
 
-  end # Keymaps
+      it { described.must_respond_to(:keymaps) }
+
+    end # Keymaps
+
+  end # Input
 
 end # Vedeu

data/test/lib/vedeu/input/keys_test.rb

@@ -2,17 +2,21 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Keys do
+  module Input
 
-    let(:described) { Vedeu::Keys }
-    let(:instance)  { described.new }
+    describe Keys do
 
-    it { described.superclass.must_equal(Vedeu::Collection) }
+      let(:described) { Vedeu::Input::Keys }
+      let(:instance)  { described.new }
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-    end
+      it { described.superclass.must_equal(Vedeu::Collection) }
 
-  end # Keys
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+      end
+
+    end # Keys
+
+  end # Input
 
 end # Vedeu

data/test/lib/vedeu/input/mapper_test.rb

@@ -2,87 +2,95 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Mapper do
-
-    let(:described)  { Vedeu::Mapper }
-    let(:instance)   { described.new(key, keymap, repository) }
-    let(:key)        {}
-    let(:keymap)     {}
-    let(:repository) {}
-
-    before { Vedeu.keymaps.reset }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@key').must_equal(key) }
-      it { instance.instance_variable_get('@name').must_equal(keymap) }
-      it do
-        instance.instance_variable_get('@repository').must_equal(Vedeu.keymaps)
-      end
+  module Input
+
+    describe Mapper do
+
+      let(:described)  { Vedeu::Input::Mapper }
+      let(:instance)   { described.new(key, keymap, repository) }
+      let(:key)        {}
+      let(:keymap)     {}
+      let(:repository) {}
 
-      context 'when the repository is provided' do
-        let(:repository) { Vedeu::Repository.new }
+      before { Vedeu.keymaps.reset }
 
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@key').must_equal(key) }
+        it { instance.instance_variable_get('@name').must_equal(keymap) }
         it do
-          instance.instance_variable_get('@repository').must_equal(repository)
+          instance.instance_variable_get('@repository').must_equal(Vedeu.keymaps)
+        end
+
+        context 'when the repository is provided' do
+          let(:repository) { Vedeu::Repository.new }
+
+          it do
+            instance.instance_variable_get('@repository').must_equal(repository)
+          end
         end
       end
-    end
 
-    describe '.keypress' do
-      let(:keymap) { 'test' }
+      describe '.keypress' do
+        let(:keymap) { 'test' }
 
-      subject { described.keypress(key, keymap) }
+        subject { described.keypress(key, keymap) }
 
-      context 'when the key is not provided' do
-        it { subject.must_equal(false) }
-      end
+        context 'when the key is not provided' do
+          it { subject.must_equal(false) }
+        end
 
-      context 'when the key is provided' do
-        let(:key) { 'a' }
+        context 'when the key is provided' do
+          let(:key) { 'a' }
 
-        context 'and the key is defined' do
-          let(:key_test) { Key.new('a') { :do_something } }
-          let(:keymap_test) { Keymap.new(name: 'test', keys: [key_test]) }
+          context 'and the key is defined' do
+            let(:key_test) { Vedeu::Input::Key.new('a') { :do_something } }
+            let(:keymap_test) {
+              Vedeu::Input::Keymap.new(name: 'test', keys: [key_test])
+            }
 
-          before { Vedeu.keymaps.store(keymap_test) }
+            before { Vedeu.keymaps.store(keymap_test) }
 
-          it { subject.must_equal(true) }
-        end
+            it { subject.must_equal(true) }
+          end
 
-        context 'and the key is not defined' do
-          it { subject.must_equal(false) }
+          context 'and the key is not defined' do
+            it { subject.must_equal(false) }
+          end
         end
       end
-    end
 
-    describe '.valid?' do
-      let(:keymap) { 'test' }
+      describe '.valid?' do
+        let(:keymap) { 'test' }
 
-      subject { described.valid?(key, keymap) }
+        subject { described.valid?(key, keymap) }
 
-      context 'when the key is not provided' do
-        it { subject.must_equal(false) }
-      end
+        context 'when the key is not provided' do
+          it { subject.must_equal(false) }
+        end
 
-      context 'when the key is provided' do
-        let(:key) { 'a' }
+        context 'when the key is provided' do
+          let(:key) { 'a' }
 
-        context 'and the key is defined' do
-          let(:key_test) { Key.new('a') { :do_something } }
-          let(:keymap_test) { Keymap.new(name: 'test', keys: [key_test]) }
+          context 'and the key is defined' do
+            let(:key_test) { Vedeu::Input::Key.new('a') { :do_something } }
+            let(:keymap_test) {
+              Vedeu::Input::Keymap.new(name: 'test', keys: [key_test])
+            }
 
-          before { Vedeu.keymaps.store(keymap_test) }
+            before { Vedeu.keymaps.store(keymap_test) }
 
-          it { subject.must_equal(false) }
-        end
+            it { subject.must_equal(false) }
+          end
 
-        context 'and the key is not defined' do
-          it { subject.must_equal(true) }
+          context 'and the key is not defined' do
+            it { subject.must_equal(true) }
+          end
         end
       end
-    end
 
-  end # Mapper
+    end # Mapper
+
+  end # Input
 
 end # Vedeu

data/test/lib/vedeu/input/translator_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Input
+
+    describe Translator do
+
+      let(:described) { Vedeu::Input::Translator }
+      let(:instance)  { described.new(code) }
+      let(:code)      {}
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@code').must_equal(code) }
+      end
+
+      describe '.translate' do
+        context 'when the code is not recognised' do
+          it { described.translate('a').must_equal('a') }
+        end
+
+        context 'when the code is recognised' do
+          it { described.translate("\e[H").must_equal(:home) }
+        end
+      end
+
+      describe '#translate' do
+        it { instance.must_respond_to(:translate) }
+      end
+
+    end # Translator
+
+  end # Input
+
+end # Vedeu

data/test/lib/vedeu/logging/debug_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Logging
+
+    describe Debug do
+
+      let(:described) { Vedeu::Logging::Debug }
+
+      before do
+        File.stubs(:open).with('/tmp/profile.html', 'w').returns(:some_code)
+      end
+
+      describe '.debug' do
+        let(:filename)  { 'profile.html' }
+        let(:some_code) { :some_code }
+
+        context 'when the block is not given' do
+          subject { described.debug(filename) }
+
+          it { subject.must_equal(nil) }
+        end
+
+        context 'when the block is given' do
+          subject { described.debug(filename) { some_code } }
+
+          it {
+            ::File.expects(:open).with('/tmp/profile.html', 'w')
+            subject
+          }
+        end
+      end
+
+    end # Debug
+
+  end # Logging
+
+end # Vedeu

data/test/lib/vedeu/logging/lockless_log_device_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Logging
+
+    describe LocklessLogDevice do
+
+      let(:described)        { Vedeu::Logging::LocklessLogDevice }
+      let(:instance)         { described.new(file_or_filename) }
+      let(:file_or_filename) {}
+
+      describe '#initialize' do
+        # it { instance.must_be_instance_of(described) }
+        # it {
+        #   instance.instance_variable_get('@file_or_filename').
+        #     must_equal(file_or_filename)
+        # }
+
+        # @todo Add more tests.
+        # it { skip }
+      end
+
+      describe '#write' do
+        subject { instance.write(message) }
+
+        # @todo Add more tests.
+        # it { skip }
+      end
+
+      describe '#close' do
+        subject { instance.close }
+
+        # @todo Add more tests.
+        # it { skip }
+      end
+
+    end # LocklessLogDevice
+
+  end # Logging
+
+end # Vedeu

data/test/lib/vedeu/logging/log_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Logging
+
+    describe Log do
+
+      let(:described) { Vedeu::Logging::Log }
+      let(:_message)  { 'Some message...' }
+      let(:force)     { false }
+      let(:type)      { :info }
+
+      describe '.log' do
+        subject { described.log(message: _message, force: force, type: type) }
+
+        it { subject.must_equal(
+          "\e[97m[info]   \e[39m\e[39mSome message...\e[39m"
+        ) }
+      end
+
+      describe '.log_stdout' do
+        let(:type)     { :create }
+        let(:_message) { 'Logging to stdout...' }
+
+        subject { described.log_stdout(type: type, message: _message) }
+
+        it {
+          capture_io { subject }.must_equal(
+            ["\e[92m[create] \e[39m\e[32mLogging to stdout...\e[39m\n", ""]
+          )
+        }
+      end
+
+      describe '.log_stdout' do
+        let(:type)     { :debug }
+        let(:_message) { 'Logging to stderr...' }
+
+        subject { described.log_stderr(type: type, message: _message) }
+
+        it {
+          capture_io { subject }.must_equal(
+            ["", "\e[91m[debug]  \e[39m\e[31mLogging to stderr...\e[39m\n"]
+          )
+        }
+      end
+
+    end # Log
+
+  end # Logging
+
+end # Vedeu

data/test/lib/vedeu/logging/mono_logger_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Logging
+
+    describe MonoLogger do
+
+      let(:described) { Vedeu::Logging::MonoLogger }
+      let(:instance)  { described.new(logdev) }
+      let(:logdev)    {}
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it {
+          instance.instance_variable_get('@level').must_equal(Logger::DEBUG)
+        }
+        it {
+          instance.instance_variable_get('@default_formatter').
+            must_be_instance_of(::Logger::Formatter)
+        }
+        it { instance.instance_variable_get('@Formatter').must_equal(nil) }
+
+        context 'when a log device is given' do
+          # it {
+          #   instance.instance_variable_get('@logdev').
+          #     must_be_instance_of(Vedeu::Logging::LocklessLogDevice)
+          # }
+        end
+
+        context 'when a log device is not given' do
+          # it {
+          #   instance.instance_variable_get('@logdev').
+          #     must_be_instance_of(Vedeu::Logging::LocklessLogDevice)
+          # }
+        end
+      end
+
+    end # MonoLogger
+
+  end # Logging
+
+end # Vedeu

data/test/lib/vedeu/logging/timer_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Logging
+
+    describe Timer do
+
+      let(:described) { Vedeu::Logging::Timer }
+      let(:instance)  { described.new(_message) }
+      let(:_message)  { 'Testing' }
+      let(:_time)     { mock('Time') }
+      let(:started)   { 1434492219.5238185 }
+
+      before do
+        Time.stubs(:now).returns(_time)
+        _time.stubs(:to_f).returns(started)
+      end
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@message').must_equal(_message) }
+        it { instance.instance_variable_get('@started').must_equal(started) }
+      end
+
+      describe '.timer' do
+        it { described.must_respond_to(:timer) }
+      end
+
+      describe '#measure' do
+        subject { instance.measure { } }
+
+        it {
+          Vedeu.expects(:log).with(type:    :timer,
+                                   message: "Testing took 0.0ms.")
+          subject
+        }
+      end
+
+    end # Timer
+
+  end # Logging
+
+end # Vedeu

data/test/lib/vedeu/{dsl/menu_test.rb → menus/dsl_test.rb}

@@ -2,13 +2,13 @@ require 'test_helper'
 
 module Vedeu
 
-  module DSL
+  module Menus
 
-    describe Menu do
+    describe DSL do
 
-      let(:described)  { Vedeu::DSL::Menu }
+      let(:described)  { Vedeu::Menus::DSL }
       let(:instance)   { described.new(model) }
-      let(:model)      { Vedeu::Menu.new(attributes) }
+      let(:model)      { Vedeu::Menus::Menu.new(attributes) }
       let(:attributes) {
         {
           collection: collection,
@@ -70,8 +70,8 @@ module Vedeu
         end
       end
 
-    end # Menu
+    end # DSL
 
-  end # DSL
+  end # Menus
 
 end # Vedeu