vedeu 0.6.21 → 0.6.22

data/lib/vedeu/runtime/launcher.rb

@@ -20,7 +20,7 @@ module Vedeu
                       stdout = STDOUT,
                       stderr = STDERR,
                       kernel = Kernel)
-      new(argv, stdin, stdout, stderr, kernel).debug_execute!
+      new(argv, stdin, stdout, stderr, kernel).execute!
     end
     # :nocov:
 
@@ -45,47 +45,35 @@ module Vedeu
       @exit_code = 1
     end
 
-    # :nocov:
-    # If debugging is enabled, execute the application within the
-    # debugging context. At the moment, this simple uses 'ruby-prof'
-    # to profile the running application.
-    #
-    # @return [void]
-    def debug_execute!
-      if configuration.debug?
-        Vedeu.debug { execute! }
-
-      else
-        execute!
-
-      end
-
-      terminate!
-    end
-    # :nocov:
-
     # Alters the STD[IN|OUT|ERR] to those requested by the client
     # application, then starts the application. If an uncaught
     # exception occurs during the application runtime, we exit
     # ungracefully with any error message(s).
     #
+    # If profiling is enabled, execute the application within the
+    # profiling context. At the moment, this simple uses 'ruby-prof'
+    # to profile the running application.
+    #
     # @return [void]
     def execute!
       $stdin  = @stdin
       $stdout = @stdout
       $stderr = @stderr
 
-      Vedeu::Runtime::Application.start(configuration)
+      optionally_profile { Vedeu::Runtime::Application.start(configuration) }
 
       @exit_code = 0
 
+      terminate!
+
     rescue StandardError => uncaught_exception
-      Vedeu.log_stdout(type: :error, message: uncaught_exception.message)
+      output = if configuration.debug?
+                 uncaught_exception.backtrace.join("\n")
+               else
+                 uncaught_exception.message
+               end
 
-      if configuration.debug?
-        Vedeu.log_stdout(type:    :error,
-                         message: uncaught_exception.backtrace.join("\n"))
-      end
+      Vedeu.log_stdout(type: :error, message: output)
     end
 
     protected
@@ -96,6 +84,17 @@ module Vedeu
 
     private
 
+    # @return [void]
+    def optionally_profile
+      if configuration.profile?
+        Vedeu.profile { yield }
+
+      else
+        yield
+
+      end
+    end
+
     # :nocov:
     # Terminates the application after resetting $stdin, $stdout and
     # $stderr.

data/lib/vedeu/version.rb

@@ -1,6 +1,6 @@
 module Vedeu
 
   # The current version of Vedeu.
-  VERSION = '0.6.21'
+  VERSION = '0.6.22'
 
 end

data/test/lib/vedeu/bindings/refresh_test.rb

@@ -11,6 +11,7 @@ module Vedeu
         it { Vedeu.bound?(:_refresh_cursor_).must_equal(true) }
         it { Vedeu.bound?(:_refresh_group_).must_equal(true) }
         it { Vedeu.bound?(:_refresh_view_).must_equal(true) }
+        it { Vedeu.bound?(:_refresh_view_content_).must_equal(true) }
       end
 
     end # Refresh

data/test/lib/vedeu/bindings/visibility_test.rb

@@ -10,6 +10,7 @@ module Vedeu
         it { Vedeu.bound?(:_clear_).must_equal(true) }
         it { Vedeu.bound?(:_clear_group_).must_equal(true) }
         it { Vedeu.bound?(:_clear_view_).must_equal(true) }
+        it { Vedeu.bound?(:_clear_view_content_).must_equal(true) }
 
         it { Vedeu.bound?(:_cursor_hide_).must_equal(true) }
         it { Vedeu.bound?(:_cursor_show_).must_equal(true) }

data/test/lib/vedeu/borders/border_test.rb

@@ -408,12 +408,12 @@ module Vedeu
       end
 
       describe '#render' do
-        before { Vedeu::Borders::Render.stubs(:with) }
+        before { Vedeu::Borders::Render.stubs(:render) }
 
         subject { instance.render }
 
         it {
-          Vedeu::Borders::Render.expects(:with).with(instance)
+          Vedeu::Borders::Render.expects(:render).with(instance)
           subject
         }
       end

data/test/lib/vedeu/borders/render_test.rb

@@ -28,8 +28,6 @@ module Vedeu
       let(:show_left)   { true }
       let(:show_right)  { true }
 
-      it { described.must_respond_to(:with) }
-
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }
         it { instance.instance_variable_get('@border').must_equal(border) }
@@ -39,86 +37,31 @@ module Vedeu
         it { instance.must_respond_to(:render) }
       end
 
-      describe '.with' do
+      describe '.render' do
         let(:geometry) {
           Vedeu::Geometry::Geometry.new(name: _name, x: 1, xn: 7, y: 1, yn: 4)
         }
         let(:interface) {
-          Vedeu::Models::Interface.new(name: _name, visible: visible)
+          Vedeu::Models::Interface.new(name: _name, visible: true)
         }
         before do
           Vedeu.geometries.stubs(:by_name).returns(geometry)
           Vedeu.interfaces.stubs(:by_name).returns(interface)
         end
 
-        subject { described.with(border) }
-
-        context 'when the interface is not visible' do
-          it { subject.must_equal([]) }
-        end
-
-        context 'when the interface is visible' do
-          let(:visible) { true }
-
-          context 'when the border is not enabled' do
-            it { subject.must_equal([]) }
-          end
-
-          context 'when the border is enabled' do
-            let(:enabled) { true }
-
-            context 'and a title is given' do
-              let(:title) { 'T' }
-
-              # @todo Add more tests.
-              it { subject.size.must_equal(18) }
-            end
-
-            context 'and a title is not given' do
-              # @todo Add more tests.
-              it { subject.size.must_equal(18) }
-            end
+        subject { described.render(border) }
 
-            context 'and a caption is given' do
-              let(:caption) { 'C' }
+        context 'when the border is enabled' do
+          let(:enabled) { true }
 
-              # @todo Add more tests.
-              it { subject.size.must_equal(18) }
-            end
-
-            context 'and a caption is not given' do
-              # @todo Add more tests.
-              it { subject.size.must_equal(18) }
-            end
-
-            context 'and the left side is disabled' do
-              let(:show_left) { false }
-
-              # @todo Add more tests.
-              it { subject.size.must_equal(16) }
-            end
-
-            context 'and the right side is disabled' do
-              let(:show_right) { false }
-
-              # @todo Add more tests.
-              it { subject.size.must_equal(16) }
-            end
-
-            context 'and the top side is disabled' do
-              let(:show_top) { false }
-
-              # @todo Add more tests.
-              it { subject.size.must_equal(13) }
-            end
-
-            context 'and the bottom side is disabled' do
-              let(:show_bottom) { false }
+          it {
+            Vedeu::Output::Output.expects(:render)
+            subject
+          }
+        end
 
-              # @todo Add more tests.
-              it { subject.size.must_equal(13) }
-            end
-          end
+        context 'when the border is not enabled' do
+          it { subject.must_equal(nil) }
         end
       end
 

data/test/lib/vedeu/buffers/buffer_test.rb

@@ -103,32 +103,6 @@ module Vedeu
         end
       end
 
-      describe '#hide' do
-        before { Vedeu.stubs(:trigger) }
-
-        subject { instance.hide }
-
-        it {
-          Vedeu.expects(:trigger).with(:_clear_view_, _name)
-          subject
-        }
-      end
-
-      describe '#show' do
-        before do
-          Vedeu.stubs(:log)
-          # Vedeu::Clear::Interface.stubs(:render)
-          Vedeu::Output::Output.stubs(:render)
-        end
-
-        subject { instance.show }
-
-        it {
-          Vedeu::Output::Output.expects(:render)
-          subject
-        }
-      end
-
       describe '#render' do
         before {
           Vedeu.stubs(:log)
@@ -136,11 +110,6 @@ module Vedeu
         }
 
         subject { instance.render }
-
-        it {
-          Vedeu::Output::Output.expects(:render)
-          subject
-        }
       end
 
     end # Buffer

data/test/lib/vedeu/buffers/refresh_test.rb

@@ -30,16 +30,8 @@ module Vedeu
         end
 
         context 'when Vedeu is ready' do
-          context 'when the name is not present' do
-            let(:_name) { '' }
-
-            it { proc { subject }.must_raise(Vedeu::Error::MissingRequired) }
-          end
-
-          context 'when the name is present' do
-            # @todo Add more tests.
-            # it { skip }
-          end
+          # @todo Add more tests.
+          # it { skip }
         end
       end
 

data/test/lib/vedeu/cursors/refresh_test.rb

@@ -48,14 +48,14 @@ module Vedeu
           let(:oy) { 3 }
 
           it 'refreshes the view' do
-            Vedeu.expects(:trigger).with(:_refresh_view_, _name)
+            Vedeu.expects(:trigger).with(:_refresh_view_content_, _name)
             subject
           end
         end
 
         context 'when the cursors offset position is inside the viewable area' do
           it 'does not refresh the view' do
-            Vedeu.expects(:trigger).with(:_refresh_view_, _name).never
+            Vedeu.expects(:trigger).with(:_refresh_view_content_, _name).never
             subject
           end
         end

data/test/lib/vedeu/editor/document_test.rb

@@ -59,12 +59,12 @@ module Vedeu
       end
 
       describe '#clear' do
-        before { Vedeu.stubs(:trigger).with(:_clear_view_, _name) }
+        before { Vedeu.stubs(:trigger).with(:_clear_view_content_, _name) }
 
         subject { instance.clear }
 
         it {
-          Vedeu.expects(:trigger).with(:_clear_view_, _name)
+          Vedeu.expects(:trigger).with(:_clear_view_content_, _name)
           subject
         }
       end
@@ -183,7 +183,7 @@ module Vedeu
         let(:output) { "\e[1;1HA\e[2;1HB\e[3;1HC\e[1;1H\e[?25h" }
 
         before {
-          Vedeu.stubs(:trigger).with(:_clear_view_, _name)
+          Vedeu.stubs(:trigger).with(:_clear_view_content_, _name)
           Vedeu::Output::Output.stubs(:render)
         }
 

data/test/lib/vedeu/logging/debug_test.rb

@@ -12,18 +12,18 @@ module Vedeu
         File.stubs(:open).with('/tmp/profile.html', 'w').returns(:some_code)
       end
 
-      describe '.debug' do
+      describe '.profile' do
         let(:filename)  { 'profile.html' }
         let(:some_code) { :some_code }
 
         context 'when the block is not given' do
-          subject { described.debug(filename) }
+          subject { described.profile(filename) }
 
           it { subject.must_equal(nil) }
         end
 
         context 'when the block is given' do
-          subject { described.debug(filename) { some_code } }
+          subject { described.profile(filename) { some_code } }
 
           it {
             ::File.expects(:open).with('/tmp/profile.html', 'w')

data/test/lib/vedeu/logging/timer_test.rb

@@ -28,13 +28,31 @@ module Vedeu
       end
 
       describe '#measure' do
-        subject { instance.measure { } }
+        context 'when the block is given' do
+          subject { instance.measure { :thing_to_be_measured } }
 
-        it {
-          Vedeu.expects(:log).with(type:    :timer,
-                                   message: "Testing took 0.0ms.")
-          subject
-        }
+          context 'when debugging is enabled' do
+            before { Vedeu::Configuration.stubs(:debug?).returns(true) }
+
+            it {
+              Vedeu.expects(:log).with(type:    :timer,
+                                       message: "Testing took 0.0ms.")
+              subject
+            }
+          end
+
+          context 'when debugging is disabled' do
+            before { Vedeu::Configuration.stubs(:debug?).returns(false) }
+
+            it { subject.must_equal(:thing_to_be_measured) }
+          end
+        end
+
+        context 'when the block is not given' do
+          subject { instance.measure }
+
+          it { proc { subject }.must_raise(Vedeu::Error::RequiresBlock) }
+        end
       end
 
     end # Timer

data/test/lib/vedeu/models/interface_test.rb

@@ -70,27 +70,23 @@ module Vedeu
       end
 
       describe '#hide' do
-        let(:buffer) { Vedeu::Buffers::Buffer.new }
-
-        before { Vedeu.buffers.stubs(:by_name).returns(buffer) }
+        before { Vedeu.stubs(:trigger) }
 
         subject { instance.hide }
 
         it {
-          Vedeu.buffers.by_name('hydrogen').expects(:hide)
+          Vedeu.expects(:trigger).with(:_clear_view_, _name)
           subject
         }
       end
 
       describe '#show' do
-        let(:buffer) { Vedeu::Buffers::Buffer.new }
-
-        before { Vedeu.buffers.stubs(:by_name).returns(buffer) }
+        before { Vedeu.stubs(:trigger) }
 
         subject { instance.show }
 
         it {
-          Vedeu.buffers.by_name('hydrogen').expects(:show)
+          Vedeu.expects(:trigger).with(:_refresh_view_, _name)
           subject
         }
       end

data/test/lib/vedeu/models/views/view_test.rb

@@ -60,32 +60,22 @@ module Vedeu
       end
 
       describe '#render' do
-        subject { instance.render }
-
-        context 'when the view is not visible' do
-          it { subject.must_equal([]) }
+        before do
+          Vedeu.stubs(:trigger).with(:_clear_view_content_, _name)
+          Vedeu::Output::Viewport.stubs(:render).with(instance)
         end
 
-        context 'when the view is visible' do
-          let(:interface) { Vedeu::Models::Interface.new(visible: true) }
-          let(:border)    { Vedeu::Borders::Border.new(name: _name, enabled: false) }
+        subject { instance.render }
 
-          before do
-            Vedeu.stubs(:trigger)
-            Vedeu.interfaces.stubs(:by_name).with(_name).returns(interface)
-            Vedeu::Output::Viewport.stubs(:render)
-            Vedeu.borders.stubs(:by_name).with(_name).returns(border)
-            border.stubs(:render)
-          end
+        it {
+          Vedeu.expects(:trigger).with(:_clear_view_content_, _name)
+          subject
+        }
 
-          it {
-            Vedeu.expects(:trigger).with(:_clear_view_, _name)
-            Vedeu::Output::Viewport.expects(:render).with(instance)
-            Vedeu.borders.expects(:by_name).with(_name).returns(border)
-            border.expects(:render)
-            subject
-          }
-        end
+        it {
+          Vedeu::Output::Viewport.expects(:render).with(instance)
+          subject
+        }
       end
 
       describe '#store_immediate' do