vedeu 0.2.12 → 0.3.0

data/test/lib/vedeu/dsl/components/border_test.rb

@@ -0,0 +1,414 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Border do
+
+      let(:described)  { Vedeu::DSL::Border }
+      let(:instance)   { described.new(model) }
+      let(:model)      { Vedeu::Border.new(interface, attributes) }
+      let(:client)     {}
+      let(:interface)  { mock('Interface') }
+      let(:attributes) { {} }
+      let(:boolean)    { true }
+
+      before do
+        Vedeu.interfaces.reset
+        Vedeu.interface 'borders' do
+          geometry do
+            height 3
+            width  3
+          end
+          lines do
+            line ''
+          end
+        end
+      end
+
+      describe '#initialize' do
+        subject { instance }
+
+        it { subject.must_be_instance_of(Vedeu::DSL::Border) }
+        it { subject.instance_variable_get('@model').must_equal(model) }
+        it { subject.instance_variable_get('@client').must_equal(client) }
+      end
+
+      describe '#bottom_left' do
+        let(:char) { 'C' }
+
+        subject { instance.bottom_left(char) }
+
+        it { subject.must_be_instance_of(String) }
+        it { subject.must_equal('C') }
+
+        context 'DSL #bottom_left' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                bottom_left '<'
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of bottom_left within border' do
+            subject.border.to_s.must_equal(
+              "\e(0l\e(B\e(0q\e(B\e(0k\e(B\n" \
+              "\e(0x\e(B \e(0x\e(B\n" \
+              "\e(0<\e(B\e(0q\e(B\e(0j\e(B"
+            )
+          end
+        end
+      end
+
+      describe '#bottom_right' do
+        let(:char) { 'D' }
+
+        subject { instance.bottom_right(char) }
+
+        it { subject.must_be_instance_of(String) }
+        it { subject.must_equal('D') }
+
+        context 'DSL #bottom_right' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                bottom_right '>'
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of bottom_right within border' do
+            subject.border.to_s.must_equal(
+              "\e(0l\e(B\e(0q\e(B\e(0k\e(B\n" \
+              "\e(0x\e(B \e(0x\e(B\n" \
+              "\e(0m\e(B\e(0q\e(B\e(0>\e(B"
+            )
+          end
+        end
+      end
+
+      describe '#horizontal' do
+        let(:char) { 'H' }
+
+        subject { instance.horizontal(char) }
+
+        it { subject.must_be_instance_of(String) }
+        it { subject.must_equal('H') }
+
+        context 'DSL #horizontal' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                horizontal '~'
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of horizontal within border' do
+            subject.border.to_s.must_equal(
+              "\e(0l\e(B\e(0~\e(B\e(0k\e(B\n" \
+              "\e(0x\e(B \e(0x\e(B\n" \
+              "\e(0m\e(B\e(0~\e(B\e(0j\e(B"
+            )
+          end
+        end
+      end
+
+      describe '#show_bottom' do
+        subject { instance.show_bottom(boolean) }
+
+        it { subject.must_be_instance_of(TrueClass) }
+
+        context 'when false' do
+          let(:boolean) { false }
+
+          it { subject.must_be_instance_of(FalseClass) }
+        end
+
+        context 'DSL #show_bottom' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                show_bottom ''
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of show_bottom within border' do
+            subject.border.to_s.must_equal(
+              "\e(0l\e(B\e(0q\e(B\e(0k\e(B\n" \
+              "\e(0x\e(B \e(0x\e(B\n" \
+              "\e(0m\e(B\e(0q\e(B\e(0j\e(B"
+            )
+          end
+        end
+      end
+
+      describe '#show_left' do
+        subject { instance.show_left(boolean) }
+
+        it { subject.must_be_instance_of(TrueClass) }
+
+        context 'when false' do
+          let(:boolean) { false }
+
+          it { subject.must_be_instance_of(FalseClass) }
+        end
+
+        context 'DSL #show_left' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                show_left ''
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of show_left within border' do
+            subject.border.to_s.must_equal(
+              "\e(0l\e(B\e(0q\e(B\e(0k\e(B\n" \
+              "\e(0x\e(B \e(0x\e(B\n" \
+              "\e(0m\e(B\e(0q\e(B\e(0j\e(B"
+            )
+          end
+        end
+      end
+
+      describe '#show_right' do
+        subject { instance.show_right(boolean) }
+
+        it { subject.must_be_instance_of(TrueClass) }
+
+        context 'when false' do
+          let(:boolean) { false }
+
+          it { subject.must_be_instance_of(FalseClass) }
+        end
+
+        context 'DSL #show_right' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                show_right ''
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of show_right within border' do
+            subject.border.to_s.must_equal(
+              "\e(0l\e(B\e(0q\e(B\e(0k\e(B\n" \
+              "\e(0x\e(B \e(0x\e(B\n" \
+              "\e(0m\e(B\e(0q\e(B\e(0j\e(B"
+            )
+          end
+        end
+      end
+
+      describe '#show_top' do
+        subject { instance.show_top(boolean) }
+
+        it { subject.must_be_instance_of(TrueClass) }
+
+        context 'when false' do
+          let(:boolean) { false }
+
+          it { subject.must_be_instance_of(FalseClass) }
+        end
+
+        context 'DSL #show_top' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                show_top ''
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of show_top within border' do
+            subject.border.to_s.must_equal(
+              "\e(0l\e(B\e(0q\e(B\e(0k\e(B\n" \
+              "\e(0x\e(B \e(0x\e(B\n" \
+              "\e(0m\e(B\e(0q\e(B\e(0j\e(B"
+            )
+          end
+        end
+      end
+
+      describe '#top_left' do
+        let(:char) { 'A' }
+
+        subject { instance.top_left(char) }
+
+        it { subject.must_be_instance_of(String) }
+        it { subject.must_equal('A') }
+
+        context 'DSL #top_left' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                top_left '{'
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of top_left within border' do
+            subject.border.to_s.must_equal(
+              "\e(0{\e(B\e(0q\e(B\e(0k\e(B\n" \
+              "\e(0x\e(B \e(0x\e(B\n" \
+              "\e(0m\e(B\e(0q\e(B\e(0j\e(B"
+            )
+          end
+        end
+      end
+
+      describe '#top_right' do
+        let(:char) { 'B' }
+
+        subject { instance.top_right(char) }
+
+        it { subject.must_be_instance_of(String) }
+        it { subject.must_equal('B') }
+
+        context 'DSL #top_right' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                top_right '}'
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of top_right within border' do
+            subject.border.to_s.must_equal(
+              "\e(0l\e(B\e(0q\e(B\e(0}\e(B\n" \
+              "\e(0x\e(B \e(0x\e(B\n" \
+              "\e(0m\e(B\e(0q\e(B\e(0j\e(B"
+            )
+          end
+        end
+      end
+
+      describe '#vertical' do
+        let(:char) { 'V' }
+
+        subject { instance.vertical(char) }
+
+        it { subject.must_be_instance_of(String) }
+        it { subject.must_equal('V') }
+
+        context 'DSL #vertical' do
+          subject {
+            Vedeu.interface 'borders' do
+              border do
+                vertical ':'
+              end
+              geometry do
+                height 3
+                width  3
+              end
+              lines do
+                line ''
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of vertical within border' do
+            subject.border.to_s.must_equal(
+              "\e(0l\e(B\e(0q\e(B\e(0k\e(B\n" \
+              "\e(0:\e(B \e(0:\e(B\n" \
+              "\e(0m\e(B\e(0q\e(B\e(0j\e(B"
+            )
+          end
+        end
+      end
+
+    end # Border
+
+  end # DSL
+
+end # Vedeu

data/test/lib/vedeu/dsl/components/geometry_test.rb

@@ -0,0 +1,231 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Geometry do
+
+      let(:described) { Vedeu::DSL::Geometry.new(model) }
+      let(:model)     { Vedeu::Geometry.new }
+
+      describe '#initialize' do
+        it { described.must_be_instance_of(Vedeu::DSL::Geometry) }
+        it { described.instance_variable_get('@model').must_equal(model) }
+      end
+
+      describe '#centred' do
+        subject { Vedeu::Geometry.build({}) { centred true } }
+
+        it 'sets the attribute to the value' do
+          subject.centred.must_equal(true)
+        end
+
+        context 'DSL #centred' do
+          subject {
+            Vedeu.interface 'geometry' do
+              geometry do
+                centred false
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of centred within geometry' do
+            subject.geometry.centred.must_equal(false)
+          end
+
+          context 'when no value is given' do
+            subject {
+              Vedeu.interface 'geometry' do
+                geometry do
+                  centred
+                end
+              end
+            }
+
+            it { subject.geometry.centred.must_equal(true) }
+          end
+        end
+      end
+
+      describe '#height' do
+        subject { Vedeu::Geometry.build({}) { height 6 } }
+
+        it 'sets the attribute to the value' do
+          subject.height.must_equal(6)
+        end
+
+        context 'DSL #height' do
+          subject {
+            Vedeu.interface 'geometry' do
+              geometry do
+                height 17
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of height within geometry' do
+            subject.geometry.height.must_equal(17)
+          end
+        end
+      end
+
+      describe '#name' do
+        subject { Vedeu::Geometry.build({}) { name 'chlorine' } }
+
+        it 'sets the attribute to the value' do
+          subject.name.must_equal('chlorine')
+        end
+
+        context 'DSL #name' do
+          subject {
+            Vedeu.interface 'geometry' do
+              geometry do
+                name 'other_name'
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of name within geometry' do
+            subject.geometry.name.must_equal('other_name')
+          end
+        end
+      end
+
+      describe '#width' do
+        subject { Vedeu::Geometry.build({}) { width 25 } }
+
+        it 'sets the attribute to the value' do
+          subject.width.must_equal(25)
+        end
+
+        context 'DSL #width' do
+          subject {
+            Vedeu.interface 'geometry' do
+              geometry do
+                width 29
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of width within geometry' do
+            subject.geometry.width.must_equal(29)
+          end
+        end
+      end
+
+      describe '#x' do
+        subject { Vedeu::Geometry.build({}) { x 2 } }
+
+        it 'sets the attribute to the value' do
+          subject.x.must_equal(2)
+        end
+
+        context 'when a block is given' do
+          subject {
+            Vedeu::Geometry.build({}) do
+              x do
+                3 + 4
+              end
+            end
+          }
+
+          it { subject.x.must_equal(7) }
+        end
+
+        context 'DSL #x' do
+          subject {
+            Vedeu.interface 'geometry' do
+              geometry do
+                x 7
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of x within geometry' do
+            subject.geometry.x.must_equal(7)
+          end
+
+          context 'when no value is given' do
+            subject {
+              Vedeu.interface 'geometry' do
+                geometry do
+                  x
+                end
+              end
+            }
+
+            it { subject.geometry.x.must_equal(0) }
+          end
+
+          context 'when a block is given' do
+          end
+        end
+      end
+
+      describe '#y' do
+        subject { Vedeu::Geometry.build({}) { y 5 } }
+
+        it 'sets the attribute to the value' do
+          subject.y.must_equal(5)
+        end
+
+        context 'when a block is given' do
+          subject {
+            Vedeu::Geometry.build({}) do
+              y do
+                2 + 7
+              end
+            end
+          }
+
+          it { subject.y.must_equal(9) }
+        end
+
+        context 'DSL #y' do
+          subject {
+            Vedeu.interface 'geometry' do
+              geometry do
+                y 4
+              end
+            end
+          }
+
+          it { subject.must_be_instance_of(Vedeu::Interface) }
+
+          it 'allows the use of y within geometry' do
+            subject.geometry.y.must_equal(4)
+          end
+
+          context 'when no value is given' do
+            subject {
+              Vedeu.interface 'geometry' do
+                geometry do
+                  y
+                end
+              end
+            }
+
+            it { subject.geometry.y.must_equal(0) }
+          end
+
+          context 'when a block is given' do
+          end
+        end
+      end
+
+    end # Geometry
+
+  end # DSL
+
+end # Vedeu

data/test/lib/vedeu/dsl/components/keymap_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Keymap do
+
+      let(:described) { Vedeu::DSL::Keymap }
+      let(:instance)  { described.new(model) }
+      let(:model)     { Vedeu::Keymap.new('_test_') }
+
+      describe '#initialize' do
+        subject { instance }
+
+        it { subject.must_be_instance_of(described) }
+        it { subject.instance_variable_get('@model').must_equal(model) }
+      end
+
+      describe '#key' do
+        let(:value_or_values) { ['j', :down] }
+
+        subject { instance.key(*value_or_values) { :some_action } }
+
+        context 'when a block was not given' do
+          subject { instance.key(value_or_values) }
+
+          it { proc { subject }.must_raise(InvalidSyntax) }
+        end
+
+        context 'when a key was not given' do
+          let(:value_or_values) {}
+
+          it { proc { subject }.must_raise(InvalidSyntax) }
+        end
+
+        context 'when an invalid key was given (nil)' do
+          let(:value_or_values) { ['v', nil] }
+
+          it { proc { subject }.must_raise(InvalidSyntax) }
+        end
+
+        context 'when an invalid key was given (empty)' do
+          let(:value_or_values) { ['v', ''] }
+
+          it { proc { subject }.must_raise(InvalidSyntax) }
+        end
+
+        context 'when the key is valid (not already defined)' do
+          before { model.stubs(:add).returns(Vedeu::Keymap) }
+
+          it { subject.must_equal(['j', :down]) }
+        end
+
+        context 'when the key is not valid (already defined)' do
+          # let(:key_j) { Key.new('j') { :do_something } }
+          # let(:key_down) { Key.new(:down) { :do_something } }
+
+          # before { model.stubs(:keys).returns([key_j, key_down]) }
+
+          # it { subject.must_equal(false) }
+        end
+      end
+
+      describe '#name' do
+        let(:value) { 'gold' }
+
+        subject { instance.name(value) }
+
+        it 'defines the name of the keymap' do
+          subject
+          model.name.must_equal(value)
+        end
+      end
+
+    end # Keymap
+
+  end # DSL
+
+end # Vedeu