vedeu 0.2.12 → 0.3.0

data/test/lib/vedeu/dsl/shared/colour_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Colour do
+
+      let(:described)  { Vedeu::DSL::Colour }
+
+      let(:dsl_klass)  { Vedeu::DSL::Interface.new(model) }
+      let(:model)      { Vedeu::Interface.new }
+      let(:background) { '#00ff00' }
+      let(:foreground) { '#ff00ff' }
+
+      describe '#background' do
+        subject { dsl_klass.background(background) }
+
+        it { subject.must_be_instance_of(Vedeu::Colour) }
+
+        it 'sets the background' do
+          subject.attributes.must_equal(
+            { background: '#00ff00', foreground: '' }
+          )
+        end
+
+        context 'alias method #bg' do
+          subject { dsl_klass.bg(background) }
+
+          it { subject.attributes.
+                must_equal({ background: '#00ff00', foreground: '' }) }
+        end
+
+        context 'alias method #bgcolor' do
+          subject { dsl_klass.bgcolor(background) }
+
+          it { subject.attributes.
+                must_equal({ background: '#00ff00', foreground: '' }) }
+        end
+      end
+
+      describe '#foreground' do
+        subject { dsl_klass.foreground(foreground) }
+
+        it { subject.must_be_instance_of(Vedeu::Colour) }
+
+        it 'sets the foreground' do
+          subject.attributes.must_equal(
+            { background: '', foreground: '#ff00ff' }
+          )
+        end
+
+        context 'alias method #fg' do
+          subject { dsl_klass.fg(foreground) }
+
+          it { subject.attributes.
+                must_equal({ background: '', foreground: '#ff00ff' }) }
+        end
+
+        context 'alias method #fgcolor' do
+          subject { dsl_klass.fgcolor(foreground) }
+
+          it { subject.attributes.
+                must_equal({ background: '', foreground: '#ff00ff' }) }
+        end
+      end
+
+      describe '#colour' do
+        let(:attributes) { { background: background, foreground: foreground } }
+
+        subject { dsl_klass.colour(attributes) }
+
+        it { subject.must_be_instance_of(Vedeu::Colour) }
+
+        context 'with an invalid attribute' do
+          let(:attributes) { { invalid: background, foreground: foreground } }
+
+          it 'sets only the valid attributes' do
+            subject.attributes.must_equal(
+              { background: '', foreground: '#ff00ff' }
+            )
+          end
+        end
+
+        context 'with an empty value' do
+          let(:attributes) { { background: background, foreground: '' } }
+
+          it 'sets only the valid attributes' do
+            subject.attributes.must_equal(
+              { background: '#00ff00', foreground: '' }
+            )
+          end
+        end
+      end
+
+    end # Colour
+
+  end # DSL
+
+end # Vedeu

data/test/lib/vedeu/dsl/shared/style_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Style do
+
+      describe '#style' do
+        let(:model) { Vedeu::ModelTestClass.new({}) }
+        let(:args)  { :bold }
+
+        subject { Vedeu::DSL::ModelTestClass.new(model).style(args) }
+
+        it { subject.must_be_instance_of(Vedeu::Style) }
+      end
+
+    end # Style
+
+  end # DSL
+
+end # Vedeu

data/test/lib/vedeu/dsl/shared/text_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Text do
+
+
+
+    end # Text
+
+  end # DSL
+
+end # Vedeu

data/test/lib/vedeu/dsl/shared/use_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Use do
+
+      describe '.use' do
+        context 'when an interface has not been defined' do
+          it { proc { Vedeu.use('unknown') }.must_raise(ModelNotFound) }
+        end
+
+        it 'returns an instance of the named interface' do
+          Vedeu.interface('aluminium') do
+            # ...
+          end
+
+          Vedeu.use('aluminium').must_be_instance_of(Vedeu::Interface)
+        end
+      end
+
+    end # Use
+
+  end # DSL
+
+end # Vedeu

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

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Stream do
+
+      let(:described) { Vedeu::DSL::Stream }
+      let(:instance)  { described.new(model) }
+      let(:model)     { mock('Vedeu::Stream') }
+      let(:client)    {}
+
+      describe '#initialize' do
+        subject { instance }
+
+        it { subject.must_be_instance_of(Vedeu::DSL::Stream) }
+        it { subject.instance_variable_get('@model').must_equal(model) }
+        it { subject.instance_variable_get('@client').must_equal(client) }
+      end
+
+    end # Stream
+
+  end # DSL
+
+end # Vedeu

data/test/lib/vedeu/dsl/view_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe View do
+
+      let(:described) { Vedeu::DSL::View }
+
+      describe '.interface' do
+        subject {
+          described.interface('flourine') do
+            # ...
+          end
+        }
+
+        it { subject.must_be_instance_of(Vedeu::Interface) }
+
+        context 'when the block is not given' do
+          subject { described.interface }
+
+          it { proc { subject }.must_raise(InvalidSyntax) }
+        end
+
+        context 'when the name was not set' do
+          subject {
+            described.interface('') do
+              # ...
+            end
+          }
+
+          it { proc { subject }.must_raise(MissingRequired) }
+        end
+      end
+
+      describe '.renders' do
+        subject {
+          described.renders do
+            # ...
+          end
+        }
+
+        it { subject.must_be_instance_of(Array) }
+
+        context 'when the block is not given' do
+          subject { described.renders }
+
+          it { proc { subject }.must_raise(InvalidSyntax) }
+        end
+      end
+
+      describe '.views' do
+        subject {
+          described.views do
+            # ...
+          end
+        }
+
+        it { subject.must_be_instance_of(Array) }
+
+        context 'when the block is not given' do
+          subject { described.views }
+
+          it { proc { subject }.must_raise(InvalidSyntax) }
+        end
+      end
+
+    end # View
+
+  end # DSL
+
+end # Vedeu

data/test/lib/vedeu/events/all_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe '.events' do
+    subject { Vedeu.events }
+
+    it { subject.must_be_instance_of(Vedeu::Repository) }
+  end
+
+end # Vedeu

data/test/lib/vedeu/events/event_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Event do
+
+    let(:described)  { Vedeu::Event }
+    let(:instance)   { described.new(event_name, options, closure) }
+    let(:event_name) { :some_event }
+    let(:options)    { {} }
+    let(:closure)    { proc { :event_triggered } }
+
+    describe '.bind' do
+      subject { described.bind(event_name, options) { :event_triggered } }
+
+      it { subject.must_be_instance_of(TrueClass) }
+    end
+
+    # describe '.unbind' do
+    #   let(:event_name) { :chlorine }
+
+    #   before do
+    #     Vedeu.bind(:chlorine) { :some_event }
+    #   end
+
+    #   subject { instance.unbind(event_name) }
+
+    #   context 'when the event exists' do
+    #     it { subject.must_be_instance_of(TrueClass) }
+    #   end
+
+    #   context 'when the event does not exist' do
+    #     let(:event_name) { :does_not_exist }
+
+    #     it { subject.must_be_instance_of(FalseClass) }
+    #   end
+    # end
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Event) }
+      it { subject.instance_variable_get('@name').must_equal(event_name) }
+      it { subject.instance_variable_get('@options').must_equal(options) }
+      # it { subject.instance_variable_get('@closure').must_equal(closure) }
+      it { subject.instance_variable_get('@deadline').must_equal(0) }
+      it { subject.instance_variable_get('@executed_at').must_equal(0) }
+      it { subject.instance_variable_get('@now').must_equal(0) }
+      it { subject.instance_variable_get('@repository').must_equal(Vedeu.events) }
+    end
+
+    describe '#bind' do
+      subject { instance.bind }
+
+      context 'when the event name is already registered' do
+        before { Vedeu.bind(:some_event) { :already_registered } }
+
+        it { subject.must_be_instance_of(TrueClass) }
+      end
+
+      context 'when the event name is not already registered' do
+        it { subject.must_be_instance_of(TrueClass) }
+      end
+    end
+
+    describe '#trigger' do
+      it 'returns the result of calling the closure when debouncing' do
+        event = Event.new(event_name, { debounce: 0.0025 }, closure)
+        event.trigger.must_equal(nil)
+        sleep 0.0015
+        event.trigger.must_equal(nil)
+        sleep 0.0015
+        event.trigger.must_equal(:event_triggered)
+        sleep 0.0015
+        event.trigger.must_equal(nil)
+      end
+
+      it 'returns the result of calling the closure when throttling' do
+        event = Event.new(event_name, { delay: 0.0025 }, closure)
+        event.trigger.must_equal(:event_triggered)
+        sleep 0.0015
+        event.trigger.must_equal(nil)
+        sleep 0.0015
+        event.trigger.must_equal(:event_triggered)
+      end
+
+      it 'returns the result of calling the closure with its arguments' do
+        event = Event.new(event_name, options, closure)
+        event.trigger.must_equal(:event_triggered)
+      end
+    end
+
+    describe '#unbind' do
+      context 'when the event exists' do
+        before do
+          Vedeu.bind(:gallium) { :some_action }
+        end
+
+        it { Vedeu.unbind(:gallium).must_equal(true) }
+      end
+
+      context 'when the event does not exist' do
+        it { Vedeu.unbind(:gallium).must_equal(false) }
+      end
+    end
+
+  end # Event
+
+end # Vedeu

data/test/lib/vedeu/events/trigger_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Trigger do
+
+    let(:described)  { Vedeu::Trigger }
+    let(:instance)   { described.new(event_name, args) }
+    let(:event_name) { :_testing_event_ }
+    let(:args)       {}
+
+    describe '.trigger' do
+      before { Vedeu.bind(event_name) { :_only_one_result_ } }
+
+      subject { described.trigger(event_name) }
+
+      it { subject.must_equal(:_only_one_result_) }
+    end
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Vedeu::Trigger) }
+      it { subject.instance_variable_get('@name').must_equal(event_name) }
+      it { subject.instance_variable_get('@args').must_equal([args]) }
+      it { subject.instance_variable_get('@repository').must_equal(Vedeu.events) }
+    end
+
+    describe '#trigger' do
+      subject { instance.trigger }
+
+      context 'when only one result occurs from triggering the event' do
+        let(:event_name) { :_one_result_ }
+
+        before { Vedeu.bind(event_name) { :_only_one_result_ } }
+
+        it { subject.must_equal(:_only_one_result_) }
+      end
+
+      context 'when multiple results occur from triggering an event' do
+        let(:event_name) { :_multiple_results_ }
+
+        before do
+          Vedeu::Event.register(event_name) { :_result_one_ }
+          Vedeu::Event.register(event_name) { :_result_two_ }
+        end
+
+        it { subject.must_equal([:_result_one_, :_result_two_]) }
+      end
+
+      context 'when the event has not been registered' do
+        let(:event_name) { :_not_found_ }
+
+        it { subject.must_equal([]) }
+      end
+    end
+
+  end # Trigger
+
+end # Vedeu

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

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe '.keymaps' do
+    subject { Vedeu.keymaps }
+
+    it { subject.must_be_instance_of(Vedeu::Repository) }
+  end
+
+end # Vedeu

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

@@ -3,15 +3,19 @@ require 'test_helper'
 module Vedeu
 
   describe Input do
+
     let(:reader)    { mock }
     let(:keypress)  { 'a' }
-    let(:described) { Input.new(reader) }
+    let(:described) { Vedeu::Input }
+    let(:instance)  { described.new(reader) }
 
     before { reader.stubs(:read).returns(keypress) }
 
     describe '#initialize' do
-      it { return_type_for(described, Input) }
-      it { assigns(described, '@reader', reader) }
+      subject { instance }
+
+      it { subject.must_be_instance_of(Input) }
+      it { subject.instance_variable_get('@reader').must_equal(reader) }
     end
 
     describe '.capture' do

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

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Key do
+
+    let(:described) { Vedeu::Key }
+    let(:instance)  { described.new(input) { :output } }
+    let(:input)     { 'a' }
+
+    describe '.define' do
+      subject { described.define(input) { :output } }
+
+      it { subject.must_be_instance_of(Key) }
+
+      context 'when the required block is not given' do
+        subject { described.define(input) }
+
+        it { proc { subject }.must_raise(InvalidSyntax) }
+      end
+    end
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { instance.must_be_instance_of(Key) }
+      it { instance.instance_variable_get('@input').must_equal(input) }
+
+      context 'when the required block is not given' do
+        subject { described.new(input) }
+
+        it { proc { subject }.must_raise(InvalidSyntax) }
+      end
+    end
+
+    describe '#input' do
+      subject { instance.input }
+
+      it 'returns the key defined' do
+        subject.must_equal('a')
+      end
+
+      context 'alias method #key' do
+        subject { instance.key }
+
+        it { subject.must_equal('a') }
+      end
+    end
+
+    describe '#output' do
+      subject { instance.output }
+
+      it 'returns the result of calling the proc' do
+        subject.must_equal(:output)
+      end
+
+      context 'alias method #action' do
+        subject { instance.action }
+
+        it { subject.must_equal(:output) }
+      end
+
+      context 'alias method #press' do
+        subject { instance.press }
+
+        it { subject.must_equal(:output) }
+      end
+    end
+
+  end # Key
+
+end # Vedeu

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

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Keymap do
+
+    let(:described) { Vedeu::Keymap }
+    let(:instance)  { described.new(map_name, keys) }
+    let(:map_name)  { 'zirconium' }
+    let(:keys)      { [] }
+    let(:key)       { Vedeu::Key.new('a') { :output } }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Keymap) }
+      it { subject.instance_variable_get('@name').must_equal(map_name) }
+      it { subject.instance_variable_get('@keys').must_be_instance_of(Vedeu::Model::Collection) }
+      it { subject.instance_variable_get('@repository').must_equal(Vedeu.keymaps) }
+    end
+
+    describe '#add' do
+      subject { instance.add(key) }
+
+      context 'when the key is already defined' do
+        before do
+          Vedeu.keymaps.reset
+          instance.add(key)
+        end
+
+        it { subject.must_equal(false) }
+      end
+
+      context 'when the key is not already defined' do
+        it { subject.must_be_instance_of(Vedeu::Model::Collection) }
+      end
+    end
+
+    describe '#key_defined?' do
+      let(:input) { 'a' }
+
+      subject { instance.key_defined?(input) }
+
+      context 'when the input is defined' do
+        let(:keys) { Vedeu::Model::Collection.new([key]) }
+
+        it { subject.must_be_instance_of(TrueClass) }
+      end
+
+      context 'when the input is not defined' do
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+    end
+
+    describe '#use' do
+      let(:input) { 'b' }
+
+      subject { instance.use(input) }
+
+      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::Model::Collection.new([key_a, key_b, key_c]) }
+
+        it { subject.must_be_instance_of(Array) }
+        it { subject.must_equal([:key_b]) }
+      end
+
+      context 'when the input is not defined' do
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+    end
+
+    describe '#keys' do
+      subject { instance.keys }
+
+      it { subject.must_be_instance_of(Vedeu::Model::Collection) }
+    end
+
+    describe '#name' do
+      subject { instance.name }
+
+      it { subject.must_be_instance_of(String) }
+    end
+
+  end # Keymap
+
+end # Vedeu