vedeu 0.6.4 → 0.6.5

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

@@ -2,187 +2,191 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Dimension do
-
-    let(:described)  { Vedeu::Dimension }
-    let(:instance)   { described.new(attributes) }
-    let(:attributes) {
-      {
-        d:         d,
-        dn:        dn,
-        d_dn:      d_dn,
-        default:   default,
-        maximised: maximised,
-        centred:   centred,
+  module Geometry
+
+    describe Dimension do
+
+      let(:described)  { Vedeu::Geometry::Dimension }
+      let(:instance)   { described.new(attributes) }
+      let(:attributes) {
+        {
+          d:         d,
+          dn:        dn,
+          d_dn:      d_dn,
+          default:   default,
+          maximised: maximised,
+          centred:   centred,
+        }
       }
-    }
-    let(:d)         {}
-    let(:dn)        {}
-    let(:d_dn)      {}
-    let(:default)   {}
-    let(:maximised) {}
-    let(:centred)   {}
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@d').must_equal(d) }
-      it { instance.instance_variable_get('@dn').must_equal(dn) }
-      it { instance.instance_variable_get('@d_dn').must_equal(d_dn) }
-      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) }
-    end
-
-    describe '.pair' do
-      let(:d)  { 15 }
-      let(:dn) { 38 }
-
-      subject { described.pair(attributes) }
-
-      it { subject.must_be_instance_of(Array) }
-      it { subject.must_equal([15, 38]) }
-
-      context 'when maximised' do
-        let(:maximised) { true }
-        let(:default)   { 80 }
-
-        it { subject.must_equal([1, 80]) }
+      let(:d)         {}
+      let(:dn)        {}
+      let(:d_dn)      {}
+      let(:default)   {}
+      let(:maximised) {}
+      let(:centred)   {}
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@d').must_equal(d) }
+        it { instance.instance_variable_get('@dn').must_equal(dn) }
+        it { instance.instance_variable_get('@d_dn').must_equal(d_dn) }
+        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) }
       end
 
-      context 'when centred and a length can be determined' do
-        let(:centred) { true }
-        let(:default) { 80 }
+      describe '.pair' do
+        let(:d)  { 15 }
+        let(:dn) { 38 }
 
-        context 'when d and dn are given' do
-          let(:d)  { 7 }
-          let(:dn) { 47 }
+        subject { described.pair(attributes) }
 
-          it { subject.must_equal([20, 60]) }
-        end
+        it { subject.must_be_instance_of(Array) }
+        it { subject.must_equal([15, 38]) }
 
-        context 'when only a d_dn is given' do
-          let(:d_dn) { 30 }
+        context 'when maximised' do
+          let(:maximised) { true }
+          let(:default)   { 80 }
 
-          it { subject.must_equal([28, 52]) }
+          it { subject.must_equal([1, 80]) }
         end
 
-        context 'when only a default is given' do
-          it { subject.must_equal([28, 52]) }
-        end
-      end
-    end
+        context 'when centred and a length can be determined' do
+          let(:centred) { true }
+          let(:default) { 80 }
 
-    describe '#d1' do
-      subject { instance.d1 }
+          context 'when d and dn are given' do
+            let(:d)  { 7 }
+            let(:dn) { 47 }
 
-      it { subject.must_be_instance_of(Fixnum) }
+            it { subject.must_equal([20, 60]) }
+          end
 
-      context 'when not centred and/or a length cannot be determined' do
-        context 'when d is given' do
-          let(:d) { 5 }
+          context 'when only a d_dn is given' do
+            let(:d_dn) { 30 }
 
-          it { subject.must_equal(5) }
-        end
+            it { subject.must_equal([28, 52]) }
+          end
 
-        context 'when d is not given' do
-          it { subject.must_equal(1) }
+          context 'when only a default is given' do
+            it { subject.must_equal([28, 52]) }
+          end
         end
       end
 
-      context 'when centred and a length can be determined' do
-        let(:centred) { true }
-        let(:default) { 80 }
+      describe '#d1' do
+        subject { instance.d1 }
 
-        context 'when d and dn are given' do
-          let(:d)  { 7 }
-          let(:dn) { 47 }
+        it { subject.must_be_instance_of(Fixnum) }
 
-          it { subject.must_equal(20) }
-        end
+        context 'when not centred and/or a length cannot be determined' do
+          context 'when d is given' do
+            let(:d) { 5 }
 
-        context 'when only a d_dn is given' do
-          let(:d_dn) { 30 }
+            it { subject.must_equal(5) }
+          end
 
-          it { subject.must_equal(25) }
+          context 'when d is not given' do
+            it { subject.must_equal(1) }
+          end
         end
 
-        context 'when only a default is given' do
-          it { subject.must_equal(1) }
+        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
-    end
 
-    describe '#d2' do
-      subject { instance.d2 }
+      describe '#d2' do
+        subject { instance.d2 }
 
-      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 not centred and/or a length cannot be determined' do
+          context 'when d and dn are given' do
+            let(:d)  { 5 }
+            let(:dn) { 8 }
 
-          it { subject.must_equal(8) }
-        end
+            it { subject.must_equal(8) }
+          end
 
-        context 'when d and d_dn are given' do
-          let(:d)    { 5 }
-          let(:d_dn) { 2 }
+          context 'when d and d_dn are given' do
+            let(:d)    { 5 }
+            let(:d_dn) { 2 }
 
-          it { subject.must_equal(6) }
-        end
+            it { subject.must_equal(6) }
+          end
 
-        context 'when only d_dn is given' do
-          let(:d_dn) { 6 }
+          context 'when only d_dn is given' do
+            let(:d_dn) { 6 }
 
-          it { subject.must_equal(6) }
-        end
+            it { subject.must_equal(6) }
+          end
 
-        context 'when only dn is given' do
-          let(:dn) { 8 }
+          context 'when only dn is given' do
+            let(:dn) { 8 }
 
-          it { subject.must_equal(8) }
-        end
+            it { subject.must_equal(8) }
+          end
 
-        context 'when d and a default is given' do
-          let(:d)       { 1 }
-          let(:default) { 40 }
+          context 'when d and a default is given' do
+            let(:d)       { 1 }
+            let(:default) { 40 }
 
-          it { subject.must_equal(40) }
-        end
+            it { subject.must_equal(40) }
+          end
 
-        context 'when only a default is given' do
-          let(:default) { 25 }
+          context 'when only a default is given' do
+            let(:default) { 25 }
 
-          it { subject.must_equal(25) }
-        end
+            it { subject.must_equal(25) }
+          end
 
-        context 'when no default is given' do
-          it { subject.must_equal(nil) }
+          context 'when no default is given' do
+            it { subject.must_equal(nil) }
+          end
         end
-      end
 
-      context 'when centred and a length can be determined' do
-        let(:centred) { true }
-        let(:default) { 80 }
+        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 }
+          context 'when d and dn are given' do
+            let(:d)  { 7 }
+            let(:dn) { 47 }
 
-          it { subject.must_equal(60) }
-        end
+            it { subject.must_equal(60) }
+          end
 
-        context 'when only a d_dn is given' do
-          let(:d_dn) { 30 }
+          context 'when only a d_dn is given' do
+            let(:d_dn) { 30 }
 
-          it { subject.must_equal(55) }
-        end
+            it { subject.must_equal(55) }
+          end
 
-        context 'when only a default is given' do
-          it { subject.must_equal(80) }
+          context 'when only a default is given' do
+            it { subject.must_equal(80) }
+          end
         end
       end
-    end
 
-  end # Dimension
+    end # Dimension
+
+  end # Geometry
 
 end # Vedeu

data/test/lib/vedeu/{dsl/geometry_test.rb → geometry/dsl_test.rb}

@@ -2,13 +2,13 @@ require 'test_helper'
 
 module Vedeu
 
-  module DSL
+  module Geometry
 
-    describe Geometry do
+    describe DSL do
 
-      let(:described) { Vedeu::DSL::Geometry }
+      let(:described) { Vedeu::Geometry::DSL }
       let(:instance)  { described.new(model) }
-      let(:model)     { Vedeu::Geometry.new }
+      let(:model)     { Vedeu::Geometry::Geometry.new }
 
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }
@@ -36,7 +36,7 @@ module Vedeu
             end
           }
 
-          it { subject.must_be_instance_of(Vedeu::Geometry) }
+          it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
 
           it 'allows the use of centred within geometry' do
             subject.centred.must_equal(false)
@@ -90,7 +90,7 @@ module Vedeu
             end
           }
 
-          it { subject.must_be_instance_of(Vedeu::Geometry) }
+          it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
 
           it 'allows the use of height within geometry' do
             subject.height.must_equal(17)
@@ -153,7 +153,7 @@ module Vedeu
             end
           }
 
-          it { subject.must_be_instance_of(Vedeu::Geometry) }
+          it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
 
           it 'allows the use of width within geometry' do
             subject.width.must_equal(29)
@@ -172,7 +172,7 @@ module Vedeu
 
         context 'when a block is given' do
           subject {
-            Vedeu::Geometry.build({}) do
+            Vedeu::Geometry::Geometry.build({}) do
               x do
                 3 + 4
               end
@@ -189,7 +189,7 @@ module Vedeu
             end
           }
 
-          it { subject.must_be_instance_of(Vedeu::Geometry) }
+          it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
 
           it 'allows the use of x within geometry' do
             subject.x.must_equal(9)
@@ -207,7 +207,7 @@ module Vedeu
 
           context 'when a block is given' do
             subject {
-              Vedeu::Geometry.build({}) do
+              Vedeu::Geometry::Geometry.build({}) do
                 x do
                   8 + 8
                 end
@@ -230,7 +230,7 @@ module Vedeu
 
         context 'when a block is given' do
           subject {
-            Vedeu::Geometry.build({}) do
+            Vedeu::Geometry::Geometry.build({}) do
               y do
                 2 + 7
               end
@@ -247,7 +247,7 @@ module Vedeu
             end
           }
 
-          it { subject.must_be_instance_of(Vedeu::Geometry) }
+          it { subject.must_be_instance_of(Vedeu::Geometry::Geometry) }
 
           it 'allows the use of y within geometry' do
             subject.y.must_equal(4)
@@ -265,7 +265,7 @@ module Vedeu
 
           context 'when a block is given' do
             subject {
-              Vedeu::Geometry.build({}) do
+              Vedeu::Geometry::Geometry.build({}) do
                 y do
                   8 + 8
                 end
@@ -285,7 +285,7 @@ module Vedeu
 
         context 'when a block is given' do
           subject {
-            Vedeu::Geometry.build({}) do
+            Vedeu::Geometry::Geometry.build({}) do
               xn do
                 8 + 8
               end
@@ -304,7 +304,7 @@ module Vedeu
 
         context 'when a block is given' do
           subject {
-            Vedeu::Geometry.build({}) do
+            Vedeu::Geometry::Geometry.build({}) do
               yn do
                 5 + 4
               end
@@ -315,8 +315,8 @@ module Vedeu
         end
       end
 
-    end # Geometry
+    end # DSL
 
-  end # DSL
+  end # Geometry
 
 end # Vedeu

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

@@ -2,40 +2,44 @@ require 'test_helper'
 
 module Vedeu
 
-  describe GenericCoordinate do
-
-    let(:described)  { Vedeu::GenericCoordinate }
-    let(:instance)   { described.new(attributes) }
-    let(:attributes) {
-      {
-        name:   _name,
-        offset: offset,
-        type:   type,
+  module Geometry
+
+    describe GenericCoordinate do
+
+      let(:described)  { Vedeu::Geometry::GenericCoordinate }
+      let(:instance)   { described.new(attributes) }
+      let(:attributes) {
+        {
+          name:   _name,
+          offset: offset,
+          type:   type,
+        }
       }
-    }
-    let(:_name)  {}
-    let(:offset) {}
-    let(:type)   {}
+      let(:_name)  {}
+      let(:offset) {}
+      let(:type)   {}
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@name').must_equal(_name) }
-      it { instance.instance_variable_get('@offset').must_equal(offset) }
-      it { instance.instance_variable_get('@type').must_equal(type) }
-    end
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@name').must_equal(_name) }
+        it { instance.instance_variable_get('@offset').must_equal(offset) }
+        it { instance.instance_variable_get('@type').must_equal(type) }
+      end
 
-    describe '#dn' do
-      subject { instance.dn }
+      describe '#dn' do
+        subject { instance.dn }
 
-      # it { skip }
-    end
+        # it { skip }
+      end
 
-    describe '#position' do
-      subject { instance.position }
+      describe '#position' do
+        subject { instance.position }
 
-      # it { skip }
-    end
+        # it { skip }
+      end
 
-  end # GenericCoordinate
+    end # GenericCoordinate
+
+  end # Geometry
 
 end # Vedeu