vedeu 0.6.35 → 0.6.36

data/test/lib/vedeu/geometry/area_test.rb

@@ -38,30 +38,32 @@ module Vedeu
       describe '.from_attributes' do
         let(:attributes) {
           {
-            y:         y,
-            yn:        yn,
-            y_yn:      y_yn,
-            y_default: y_default,
-            x:         x,
-            xn:        xn,
-            x_xn:      x_xn,
-            x_default: x_default,
-            maximised: maximised,
-            centred:   centred,
-            alignment: alignment,
+            y:                    y,
+            yn:                   yn,
+            y_yn:                 y_yn,
+            y_default:            y_default,
+            x:                    x,
+            xn:                   xn,
+            x_xn:                 x_xn,
+            x_default:            x_default,
+            maximised:            maximised,
+            centred:              centred,
+            horizontal_alignment: horizontal_alignment,
+            vertical_alignment:   vertical_alignment,
           }
         }
-        let(:y)         {}
-        let(:yn)        {}
-        let(:y_yn)      {}
-        let(:y_default) {}
-        let(:x)         {}
-        let(:xn)        {}
-        let(:x_xn)      {}
-        let(:x_default) {}
-        let(:maximised) {}
-        let(:centred)   {}
-        let(:alignment) {}
+        let(:y)                    {}
+        let(:yn)                   {}
+        let(:y_yn)                 {}
+        let(:y_default)            {}
+        let(:x)                    {}
+        let(:xn)                   {}
+        let(:x_xn)                 {}
+        let(:x_default)            {}
+        let(:maximised)            {}
+        let(:centred)              {}
+        let(:horizontal_alignment) {}
+        let(:vertical_alignment)   {}
 
         subject { described.from_attributes(attributes) }
 

data/test/lib/vedeu/geometry/dimension_test.rb

@@ -10,22 +10,24 @@ module Vedeu
       let(:instance)   { described.new(attributes) }
       let(:attributes) {
         {
-          d:         d,
-          dn:        dn,
-          d_dn:      d_dn,
-          default:   default,
-          maximised: maximised,
-          centred:   centred,
-          alignment: alignment,
+          d:                    d,
+          dn:                   dn,
+          d_dn:                 d_dn,
+          default:              default,
+          maximised:            maximised,
+          centred:              centred,
+          horizontal_alignment: horizontal_alignment,
+          vertical_alignment:   vertical_alignment,
         }
       }
-      let(:d)         {}
-      let(:dn)        {}
-      let(:d_dn)      {}
-      let(:default)   {}
-      let(:maximised) {}
-      let(:centred)   {}
-      let(:alignment) {}
+      let(:d)                    {}
+      let(:dn)                   {}
+      let(:d_dn)                 {}
+      let(:default)              {}
+      let(:maximised)            {}
+      let(:centred)              {}
+      let(:horizontal_alignment) {}
+      let(:vertical_alignment)   {}
 
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }
@@ -35,216 +37,122 @@ module Vedeu
         it { instance.instance_variable_get('@default').must_equal(default) }
         it { instance.instance_variable_get('@maximised').must_equal(maximised) }
         it { instance.instance_variable_get('@centred').must_equal(centred) }
-        it { instance.instance_variable_get('@alignment').must_equal(alignment) }
+        it { instance.instance_variable_get('@horizontal_alignment').must_equal(horizontal_alignment) }
+        it { instance.instance_variable_get('@vertical_alignment').must_equal(vertical_alignment) }
       end
 
-      describe '.pair' do
-        let(:d)  { 15 }
-        let(:dn) { 38 }
+      # describe '.pair' do
+      #   let(:d)  { 15 }
+      #   let(:dn) { 38 }
 
-        subject { described.pair(attributes) }
+      #   subject { described.pair(attributes) }
 
-        it { subject.must_be_instance_of(Array) }
-        it { subject.must_equal([15, 38]) }
+      #   it { subject.must_be_instance_of(Array) }
+      #   it { subject.must_equal([15, 38]) }
 
-        context 'when maximised' do
-          let(:maximised) { true }
-          let(:default)   { 80 }
+      #   context 'when maximised' do
+      #     let(:maximised) { true }
+      #     let(:default)   { 80 }
 
-          it { subject.must_equal([1, 80]) }
-        end
+      #     it { subject.must_equal([1, 80]) }
+      #   end
 
-        context 'when left aligned' do
-          let(:alignment) { :left }
-          let(:default)   { 80 }
+      #   context 'when bottom aligned' do
+      #     let(:alignment) { :bottom }
 
-          context 'when a width (d_dn) is set' do
-            let(:d_dn) { 20 }
+      #     it { proc { subject }.must_raise(Vedeu::Error::NotImplemented) }
+      #   end
 
-            it { subject.must_equal([1, 20]) }
+      #   context 'when left aligned' do
+      #     let(:alignment) { :left }
+      #     let(:default)   { 80 }
 
-            context 'when the width is greater than the terminal width' do
-              let(:d_dn) { 100 }
+      #     context 'when a width (d_dn) is set' do
+      #       let(:d_dn) { 20 }
 
-              it { subject.must_equal([1, 80]) }
-            end
-          end
+      #       it { subject.must_equal([1, 20]) }
 
-          context 'when a dn is set' do
-            it { subject.must_equal([1, 38]) }
-          end
+      #       context 'when the width is greater than the terminal width' do
+      #         let(:d_dn) { 100 }
 
-          context 'when neither width nor dn is set' do
-            let(:dn) {}
+      #         it { subject.must_equal([1, 80]) }
+      #       end
+      #     end
 
-            it { subject.must_equal([1, 80]) }
-          end
-        end
+      #     context 'when a dn is set' do
+      #       it { subject.must_equal([1, 38]) }
+      #     end
 
-        context 'when right aligned' do
-          let(:alignment) { :right }
-          let(:default)   { 80 }
+      #     context 'when neither width nor dn is set' do
+      #       let(:dn) {}
 
-          context 'when a width (d_dn) is set' do
-            let(:d_dn) { 20 }
+      #       it { subject.must_equal([1, 80]) }
+      #     end
+      #   end
 
-            it { subject.must_equal([60, 80]) }
+      #   context 'when middle aligned' do
+      #     let(:alignment) { :middle }
 
-            context 'when the width is greater than the terminal width' do
-              let(:d_dn) { 100 }
+      #     it { proc { subject }.must_raise(Vedeu::Error::NotImplemented) }
+      #   end
 
-              it { subject.must_equal([1, 80]) }
-            end
-          end
+      #   context 'when right aligned' do
+      #     let(:alignment) { :right }
+      #     let(:default)   { 80 }
 
-          context 'when a d is set' do
-            let(:d) { 58 }
+      #     context 'when a width (d_dn) is set' do
+      #       let(:d_dn) { 20 }
 
-            it { subject.must_equal([58, 80]) }
-          end
+      #       it { subject.must_equal([60, 80]) }
 
-          context 'when neither width nor d is set' do
-            let(:d) {}
+      #       context 'when the width is greater than the terminal width' do
+      #         let(:d_dn) { 100 }
 
-            it { subject.must_equal([1, 80]) }
-          end
-        end
+      #         it { subject.must_equal([1, 80]) }
+      #       end
+      #     end
 
-        context 'when centre aligned' do
-          let(:alignment) { :centre }
-          let(:default) { 80 }
+      #     context 'when a d is set' do
+      #       let(:d) { 58 }
 
-          context 'when d and dn are given' do
-            let(:d)  { 7 }
-            let(:dn) { 47 }
+      #       it { subject.must_equal([58, 80]) }
+      #     end
 
-            it { subject.must_equal([20, 60]) }
-          end
+      #     context 'when neither width nor d is set' do
+      #       let(:d) {}
 
-          context 'when only a d_dn is given' do
-            let(:d_dn) { 30 }
+      #       it { subject.must_equal([1, 80]) }
+      #     end
+      #   end
 
-            it { subject.must_equal([28, 52]) }
-          end
+      #   context 'when top aligned' do
+      #     let(:alignment) { :top }
 
-          context 'when only a default is given' do
-            it { subject.must_equal([28, 52]) }
-          end
-        end
-      end
-
-      describe '#d1' do
-        subject { instance.d1 }
-
-        it { subject.must_be_instance_of(Fixnum) }
-
-        # context 'when not centred and/or a length cannot be determined' do
-        #   context 'when d is given' do
-        #     let(:d) { 5 }
-
-        #     it { subject.must_equal(5) }
-        #   end
-
-        #   context 'when d is not given' do
-        #     it { subject.must_equal(1) }
-        #   end
-        # end
-
-        # context 'when centred and a length can be determined' do
-        #   let(:centred) { true }
-        #   let(:default) { 80 }
-
-        #   context 'when d and dn are given' do
-        #     let(:d)  { 7 }
-        #     let(:dn) { 47 }
-
-        #     it { subject.must_equal(20) }
-        #   end
-
-        #   context 'when only a d_dn is given' do
-        #     let(:d_dn) { 30 }
-
-        #     it { subject.must_equal(25) }
-        #   end
-
-        #   context 'when only a default is given' do
-        #     it { subject.must_equal(1) }
-        #   end
-        # end
-      end
-
-      describe '#d2' do
-        subject { instance.d2 }
-
-        it { subject.must_be_instance_of(Fixnum) }
+      #     it { proc { subject }.must_raise(Vedeu::Error::NotImplemented) }
+      #   end
 
-        # context 'when not centred and/or a length cannot be determined' do
-        #   context 'when d and dn are given' do
-        #     let(:d)  { 5 }
-        #     let(:dn) { 8 }
+      #   context 'when centre aligned' do
+      #     let(:alignment) { :centre }
+      #     let(:default) { 80 }
 
-        #     it { subject.must_equal(8) }
-        #   end
+      #     context 'when d and dn are given' do
+      #       let(:d)  { 7 }
+      #       let(:dn) { 47 }
 
-        #   context 'when d and d_dn are given' do
-        #     let(:d)    { 5 }
-        #     let(:d_dn) { 2 }
+      #       it { subject.must_equal([20, 60]) }
+      #     end
 
-        #     it { subject.must_equal(6) }
-        #   end
+      #     context 'when only a d_dn is given' do
+      #       let(:d_dn) { 30 }
 
-        #   context 'when only d_dn is given' do
-        #     let(:d_dn) { 6 }
+      #       it { subject.must_equal([28, 52]) }
+      #     end
 
-        #     it { subject.must_equal(6) }
-        #   end
-
-        #   context 'when only dn is given' do
-        #     let(:dn) { 8 }
-
-        #     it { subject.must_equal(8) }
-        #   end
-
-        #   context 'when d and a default is given' do
-        #     let(:d)       { 1 }
-        #     let(:default) { 40 }
-
-        #     it { subject.must_equal(40) }
-        #   end
-
-        #   context 'when only a default is given' do
-        #     let(:default) { 25 }
-
-        #     it { subject.must_equal(25) }
-        #   end
-
-        #   context 'when no default is given' do
-        #     it { subject.must_equal(nil) }
-        #   end
-        # end
-
-        # context 'when centred and a length can be determined' do
-        #   let(:centred) { true }
-        #   let(:default) { 80 }
-
-        #   context 'when d and dn are given' do
-        #     let(:d)  { 7 }
-        #     let(:dn) { 47 }
-
-        #     it { subject.must_equal(60) }
-        #   end
-
-        #   context 'when only a d_dn is given' do
-        #     let(:d_dn) { 30 }
-
-        #     it { subject.must_equal(55) }
-        #   end
-
-        #   context 'when only a default is given' do
-        #     it { subject.must_equal(80) }
-        #   end
-        # end
-      end
+      #     context 'when only a default is given' do
+      #       it { subject.must_equal([28, 52]) }
+      #     end
+      #   end
+      # end
 
     end # Dimension
 

data/test/lib/vedeu/geometry/dsl_test.rb

@@ -14,49 +14,184 @@ module Vedeu
         it { described.must_respond_to(:geometry) }
       end
 
-      describe '#alignment' do
-        let(:_value) { :none }
-        let(:width)  { 20 }
+      # describe '#alignment' do
+      #   let(:_value) { :none }
+      #   let(:width)  { 20 }
 
-        subject { instance.alignment(_value, width) }
+      #   subject { instance.alignment(_value, width) }
 
-        context 'when a value and width is given' do
-          it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
+      #   context 'when a value and width is given' do
+      #     it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
+
+      #     context 'when the value is :center' do
+      #       let(:_value) { :center }
+
+      #       it { subject.alignment.must_equal(:centre) }
+      #     end
+
+      #     context 'when the value is :centre' do
+      #       let(:_value) { :centre }
+
+      #       it { subject.alignment.must_equal(:centre) }
+      #     end
+
+      #     context 'when the value is :left' do
+      #       let(:_value) { :left }
+
+      #       it { subject.alignment.must_equal(:left) }
+      #     end
+
+      #     context 'when the value is :right' do
+      #       let(:_value) { :right }
+
+      #       it { subject.alignment.must_equal(:right) }
+      #     end
+      #   end
+
+      #   context 'when a value is not given' do
+      #     let(:_value) {}
 
-          context 'when the value is :center' do
-            let(:_value) { :center }
+      #     it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+      #   end
 
-            it { subject.alignment.must_equal(:centre) }
+      #   context 'when a width is not given' do
+      #     let(:_value) { :none }
+      #     let(:width)  {}
+
+      #     it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+      #   end
+      # end
+
+      describe '#align' do
+        let(:vertical)   { :top }
+        let(:horizontal) { :left }
+        let(:width)      { 20 }
+        let(:height)     { 20 }
+
+        subject { instance.align(vertical, horizontal, width, height) }
+
+        context 'when the vertical argument is not given' do
+          let(:vertical) {}
+
+          it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax).
+                                message.must_match(/No vertical alignment/)
+          }
+        end
+
+        context 'when the vertical argument is given' do
+          context 'when the height is not given' do
+            let(:height) {}
+
+            it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax).
+                                  message.must_equal('No height given.')
+            }
           end
 
-          context 'when the value is :centre' do
-            let(:_value) { :centre }
+          context 'when the height is given' do
+            it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
+            it { subject.vertical_alignment.must_equal(:top) }
+            it { subject.horizontal_alignment.must_equal(:left) }
+            it { subject.height.must_equal(20) }
+            it { subject.width.must_equal(20) }
+          end
+        end
+
+        context 'when the horizontal argument is not given' do
+          let(:horizontal) {}
+
+          it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax).
+                                message.must_match(/No horizontal alignment/)
+          }
+        end
+
+        context 'when the horizontal argument is given' do
+          context 'when the width is not given' do
+            let(:width) {}
 
-            it { subject.alignment.must_equal(:centre) }
+            it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax).
+                                  message.must_equal('No width given.')
+            }
           end
 
-          context 'when the value is :left' do
-            let(:_value) { :left }
+          context 'when the width is given' do
+            it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
+            it { subject.vertical_alignment.must_equal(:top) }
+            it { subject.horizontal_alignment.must_equal(:left) }
+            it { subject.height.must_equal(20) }
+            it { subject.width.must_equal(20) }
+          end
+        end
+      end
+
+      describe '#horizontal_alignment' do
+        let(:_value) {}
+        let(:width)  {}
+
+        subject { instance.horizontal_alignment(_value, width) }
 
-            it { subject.alignment.must_equal(:left) }
+        context 'when the value is not given' do
+          it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax).
+                                message.must_match(/No horizontal alignment/)
+          }
+        end
+
+        context 'when the value is given' do
+          let(:_value) { :right }
+
+          context 'when a width is not given' do
+            it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax).
+                                  message.must_equal('No width given.')
+            }
           end
 
-          context 'when the value is :right' do
-            let(:_value) { :right }
+          context 'when a width is given' do
+            let(:width) { 20 }
 
-            it { subject.alignment.must_equal(:right) }
+            it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
           end
         end
+      end
 
-        context 'when a value is not given' do
-          let(:_value) {}
+      describe '#vertical_alignment' do
+        let(:_value) {}
+        let(:height) {}
 
-          it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+        subject { instance.vertical_alignment(_value, height) }
+
+        context 'when the value is not given' do
+          it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax).
+                                message.must_match(/No vertical alignment/)
+          }
         end
 
-        context 'when a width is not given' do
-          let(:_value) { :none }
-          let(:width)  {}
+        context 'when the value is given' do
+          let(:_value) { :bottom }
+
+          context 'when a height is not given' do
+            it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax).
+                                  message.must_equal('No height given.')
+            }
+          end
+
+          context 'when a height is given' do
+            let(:height) { 20 }
+
+            it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
+          end
+        end
+      end
+
+      describe '#align_bottom' do
+        let(:height) { 20 }
+
+        subject { instance.align_bottom(height) }
+
+        context 'when a height is given' do
+          it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
+        end
+
+        context 'when a height is not given' do
+          let(:height) {}
 
           it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
         end
@@ -95,6 +230,22 @@ module Vedeu
         end
       end
 
+      describe '#align_middle' do
+        let(:height) { 20 }
+
+        subject { instance.align_middle(height) }
+
+        context 'when a height is given' do
+          it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
+        end
+
+        context 'when a height is not given' do
+          let(:height) {}
+
+          it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+        end
+      end
+
       describe '#align_right' do
         let(:width) { 20 }
 
@@ -110,6 +261,22 @@ module Vedeu
         end
       end
 
+      describe '#align_top' do
+        let(:height) { 20 }
+
+        subject { instance.align_top(height) }
+
+        context 'when a height is given' do
+          it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
+        end
+
+        context 'when a height is not given' do
+          let(:height) {}
+
+          it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+        end
+      end
+
       describe '#centred' do
         subject { instance.centred(true) }