vedeu 0.7.4 → 0.8.0

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

@@ -0,0 +1,213 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Text do
+
+      let(:described) { Vedeu::DSL::Text }
+      let(:instance)  { described.new(_value, options) }
+      let(:_value)    { 'abcde' }
+      let(:options)   {
+        {
+          align:    align,
+          client:   client,
+          colour:   colour,
+          name:     _name,
+          pad:      pad,
+          parent:   parent,
+          style:    style,
+          truncate: truncate,
+          width:    width,
+          wordwrap: wordwrap,
+        }
+      }
+      let(:align)    { :none }
+      let(:client)   {}
+      let(:colour)   {}
+      let(:_name)    { :vedeu_dsl_text }
+      let(:pad)      { ' ' }
+      let(:parent)   {}
+      let(:style)    {}
+      let(:truncate) { false }
+      let(:width)    { 2 }
+      let(:wordwrap) { false }
+
+      let(:geometry) { Vedeu::Geometries::Geometry.new(name: _name, width: 4) }
+
+      before { Vedeu.geometries.stubs(:by_name).returns(geometry) }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+
+        context 'when the value is given' do
+          it { instance.instance_variable_get('@value').must_equal(_value) }
+        end
+
+        context 'when the value is not given' do
+          let(:_value) {}
+
+          it { instance.instance_variable_get('@value').must_equal('') }
+        end
+
+        context 'when the options are given' do
+          it { instance.instance_variable_get('@options').must_equal(options) }
+        end
+
+        context 'when the options are not given' do
+          let(:options) {}
+
+          it { instance.instance_variable_get('@options').must_equal({}) }
+        end
+      end
+
+      describe '#chars' do
+        subject { instance.chars }
+
+        context 'when the value is not given' do
+          let(:_value) {}
+
+          it { subject.must_equal([]) }
+        end
+
+        context 'when the value is not a String' do
+          let(:_value) { :invalid }
+
+          it { subject.must_equal([]) }
+        end
+
+        context 'when the value is given and a String' do
+          context 'when the truncate option is set' do
+            let(:truncate) { true }
+
+            context 'when a width option is set' do
+              let(:expected) {
+                [
+                  Vedeu::Views::Char.new(name: _name, value: 'a'),
+                  Vedeu::Views::Char.new(name: _name, value: 'b'),
+                ]
+              }
+
+              it { subject.must_equal(expected) }
+            end
+
+            context 'when a width option is not set' do
+              let(:width) {}
+
+              context 'when a name option is set' do
+                let(:expected) {
+                  [
+                    Vedeu::Views::Char.new(name: _name, value: 'a'),
+                    Vedeu::Views::Char.new(name: _name, value: 'b'),
+                    Vedeu::Views::Char.new(name: _name, value: 'c'),
+                    Vedeu::Views::Char.new(name: _name, value: 'd'),
+                  ]
+                }
+
+                it { subject.must_equal(expected) }
+              end
+
+              context 'when a name option is not set' do
+                let(:_name) {}
+                let(:expected) {
+                  [
+                    Vedeu::Views::Char.new(name: _name, value: 'a'),
+                    Vedeu::Views::Char.new(name: _name, value: 'b'),
+                    Vedeu::Views::Char.new(name: _name, value: 'c'),
+                    Vedeu::Views::Char.new(name: _name, value: 'd'),
+                    Vedeu::Views::Char.new(name: _name, value: 'e'),
+                  ]
+                }
+
+                it { subject.must_equal(expected) }
+              end
+            end
+          end
+
+          context 'when the truncate option is not set' do
+            let(:expected) {
+              [
+                Vedeu::Views::Char.new(name: _name, value: 'a'),
+                Vedeu::Views::Char.new(name: _name, value: 'b'),
+                Vedeu::Views::Char.new(name: _name, value: 'c'),
+                Vedeu::Views::Char.new(name: _name, value: 'd'),
+                Vedeu::Views::Char.new(name: _name, value: 'e'),
+              ]
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'when the align option is set' do
+            let(:align) { :centre }
+
+            context 'when a width option is set' do
+              let(:expected) {
+                [
+                  Vedeu::Views::Char.new(name: _name, value: 'a'),
+                  Vedeu::Views::Char.new(name: _name, value: 'b'),
+                  Vedeu::Views::Char.new(name: _name, value: 'c'),
+                  Vedeu::Views::Char.new(name: _name, value: 'd'),
+                  Vedeu::Views::Char.new(name: _name, value: 'e'),
+                ]
+              }
+
+              it { subject.must_equal(expected) }
+            end
+
+            context 'when a width option is not set' do
+              let(:width) {}
+
+              context 'when a name option is set' do
+                let(:expected) {
+                  [
+                    Vedeu::Views::Char.new(name: _name, value: 'a'),
+                    Vedeu::Views::Char.new(name: _name, value: 'b'),
+                    Vedeu::Views::Char.new(name: _name, value: 'c'),
+                    Vedeu::Views::Char.new(name: _name, value: 'd'),
+                    Vedeu::Views::Char.new(name: _name, value: 'e'),
+                  ]
+                }
+
+                it { subject.must_equal(expected) }
+              end
+
+              context 'when a name option is not set' do
+                let(:_name) {}
+                let(:expected) {
+                  [
+                    Vedeu::Views::Char.new(name: _name, value: 'a'),
+                    Vedeu::Views::Char.new(name: _name, value: 'b'),
+                    Vedeu::Views::Char.new(name: _name, value: 'c'),
+                    Vedeu::Views::Char.new(name: _name, value: 'd'),
+                    Vedeu::Views::Char.new(name: _name, value: 'e'),
+                  ]
+                }
+
+                it { subject.must_equal(expected) }
+              end
+            end
+          end
+
+          context 'when the align option is not set' do
+            let(:expected) {
+              [
+                Vedeu::Views::Char.new(name: _name, value: 'a'),
+                Vedeu::Views::Char.new(name: _name, value: 'b'),
+                Vedeu::Views::Char.new(name: _name, value: 'c'),
+                Vedeu::Views::Char.new(name: _name, value: 'd'),
+                Vedeu::Views::Char.new(name: _name, value: 'e'),
+              ]
+            }
+
+            it { subject.must_equal(expected) }
+          end
+        end
+      end
+
+    end # Text
+
+  end # DSL
+
+end # Vedeu

data/test/lib/vedeu/dsl/string/truncate_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Truncate do
+
+      let(:described) { Vedeu::DSL::Truncate }
+      let(:instance)  { described.new(_value, options) }
+      let(:_value)    { 'abcdefghijklmnopqrstuvwxyz' }
+      let(:options)   {
+        {
+          name:     _name,
+          truncate: truncate,
+          width:    width,
+        }
+      }
+      let(:_name)    { :vedeu_dsl_truncate }
+      let(:truncate) { true }
+      let(:width)    { 15 }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+
+        context 'when the value is given' do
+          it { instance.instance_variable_get('@value').must_equal(_value) }
+        end
+
+        context 'when the value is not given' do
+          let(:_value) {}
+
+          it { instance.instance_variable_get('@value').must_equal('') }
+        end
+
+        context 'when the options are given' do
+          it { instance.instance_variable_get('@options').must_equal(options) }
+        end
+
+        context 'when the options are not given' do
+          let(:options)  { {} }
+          let(:expected) {
+            {
+              name:     nil,
+              truncate: false,
+              width:    nil,
+            }
+          }
+
+          it { instance.instance_variable_get('@options').must_equal(expected) }
+        end
+      end
+
+      describe '#text' do
+        subject { instance.text }
+
+        context 'when the option to truncate is set to true' do
+          context 'when the width option is given' do
+            let(:expected) { 'abcdefghijklmno' }
+
+            it { subject.must_equal(expected) }
+          end
+
+          context 'when the width option is not given' do
+            let(:width) {}
+
+            context 'when the name option is given' do
+              let(:geometry) {
+                Vedeu::Geometries::Geometry.new(name: _name, width: 20)
+              }
+              let(:expected) { 'abcdefghijklmnopqrst' }
+
+              before { Vedeu.geometries.stubs(:by_name).returns(geometry) }
+
+              it { subject.must_equal(expected) }
+            end
+
+            context 'when the name option is not given' do
+              let(:_name) {}
+
+              it { subject.must_equal(_value) }
+            end
+          end
+        end
+
+        context 'when the option to truncate is set to false' do
+          let(:truncate) { false }
+
+          it { subject.must_equal(_value) }
+        end
+      end
+
+    end # Truncate
+
+  end # DSL
+
+end # Vedeu

data/test/lib/vedeu/{output → dsl/string}/wordwrap_test.rb

@@ -2,11 +2,11 @@ require 'test_helper'
 
 module Vedeu
 
-  module Output
+  module DSL
 
     describe Wordwrap do
 
-      let(:described) { Vedeu::Output::Wordwrap }
+      let(:described) { Vedeu::DSL::Wordwrap }
       let(:instance)  { described.new(text, options) }
       let(:text)      { '' }
       let(:mode)      { :default }
@@ -280,6 +280,6 @@ module Vedeu
 
     end # Wordwrap
 
-  end # Output
+  end # DSL
 
 end # Vedeu

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

@@ -7,69 +7,57 @@ module Vedeu
     describe View do
 
       let(:described) { Vedeu::DSL::View }
-      let(:instance)  { described.new(model, client) }
-      let(:model)     {
-        Vedeu::Views::View.new(name: 'actinium')
-      }
-      let(:client) {}
+      let(:instance)  { described.new(model) }
+      let(:model)     { Vedeu::Views::Composition.new }
+      let(:client)    {}
 
-      describe '.renders' do
+      describe '#view' do
         subject {
-          described.renders do
+          instance.view('dysprosium') do
             # ...
           end
         }
 
-        it { described.must_respond_to(:render) }
-        it { subject.must_be_instance_of(Array) }
+        it { subject.must_be_instance_of(Vedeu::Views::Views) }
+        it { subject[0].must_be_instance_of(Vedeu::Views::View) }
 
         context 'when the block is not given' do
-          subject { described.renders }
-
-          it { proc { subject }.must_raise(Vedeu::Error::RequiresBlock) }
-        end
-
-        context 'when the block is given' do
-          it { subject.must_equal([]) }
+          it { proc { instance.view }.must_raise(Vedeu::Error::RequiresBlock) }
         end
       end
 
-      describe '.views' do
-        subject {
-          described.views do
-            # ...
-          end
-        }
+      describe '#template_for' do
+        let(:_name)    {}
+        let(:filename) {}
+        let(:object)   {}
+        let(:content)  { "Hydrogen\nCarbon\nOxygen\nNitrogen" }
+        let(:options)  { {} }
 
-        it { subject.must_be_instance_of(Array) }
+        subject { instance.template_for(_name, filename, object, options) }
 
-        context 'when the block is not given' do
-          subject { described.views }
+        context 'when the name of the view is not given' do
+          let(:filename) { 'my_interface.erb' }
 
-          it { proc { subject }.must_raise(Vedeu::Error::RequiresBlock) }
+          it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
         end
 
-        context 'when the block is given' do
-          it { subject.must_equal([]) }
-        end
-      end
+        context 'when the filename of the template is not given' do
+          let(:_name) { 'my_interface' }
 
-      describe '#lines' do
-        subject {
-          instance.lines do
-            # ...
-          end
-        }
+          it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
+        end
 
-        it { subject.must_be_instance_of(Vedeu::Views::Lines) }
+        context 'when the name and filename are given' do
+          let(:_name) { 'my_interface' }
+          let(:filename) { 'my_interface.erb' }
 
-        context 'when the required block is not given' do
-          subject { instance.lines }
+          before do
+            Vedeu::Templating::ViewTemplate.expects(:parse).
+              with(object, filename, options).returns(content)
+          end
 
-          it { proc { subject }.must_raise(Vedeu::Error::RequiresBlock) }
+          it { subject.must_be_instance_of(Vedeu::Views::Views) }
         end
-
-        it { instance.must_respond_to(:line) }
       end
 
     end # View

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

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+module Vedeu
+
+  module DSL
+
+    describe Views do
+
+      let(:described) { Vedeu::DSL::Views }
+      let(:instance)  { described.new(model, client) }
+      let(:model)     {
+        Vedeu::Views::View.new(name: 'actinium')
+      }
+      let(:client) {}
+
+      describe '.renders' do
+        subject {
+          described.renders do
+            # ...
+          end
+        }
+
+        it { described.must_respond_to(:render) }
+        it { subject.must_be_instance_of(Array) }
+
+        context 'when the block is not given' do
+          subject { described.renders }
+
+          it { proc { subject }.must_raise(Vedeu::Error::RequiresBlock) }
+        end
+
+        context 'when the block is given' do
+          it { subject.must_equal([]) }
+        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(Vedeu::Error::RequiresBlock) }
+        end
+
+        context 'when the block is given' do
+          it { subject.must_equal([]) }
+        end
+      end
+
+    end # Views
+
+  end # DSL
+
+end # Vedeu