vedeu 0.4.14 → 0.4.15

data/lib/vedeu/output/translator.rb

@@ -107,17 +107,15 @@ module Vedeu
 
     # Subclasses implement this method.
     #
-    # @param colour [String]
     # @return [String]
-    def retrieve(colour)
+    def retrieve(*)
       ''
     end
 
     # Subclasses implement this method.
     #
-    # @param colour [String]
     # @return [FalseClass]
-    def registered?(colour)
+    def registered?(*)
       false
     end
 

data/lib/vedeu/output/viewport.rb

@@ -118,41 +118,50 @@ module Vedeu
       left..(left + (geometry.width - 1))
     end
 
-    # Returns the offset for the content (the number of columns to change the
-    # viewport by on the x axis) determined by the offset (the cursor's x
-    # offset position).
-    #
     # @return [Fixnum]
     def left
-      @left ||= (ox >= width && ((ox - width) > 0)) ? ox - width : 0
+      @left ||= content_offset(ox, width)
     end
 
-    # Returns the offset for the content (the number of rows to change the
-    # viewport by on the y axis) determined by the offset (the cursor's y offset
-    # position.
-    #
     # @return [Fixnum]
     def top
-      @top ||= (oy >= height && ((oy - height) > 0)) ? oy - height : 0
+      @top ||= content_offset(oy, height)
+    end
+
+    # Returns the offset for the content (the number of rows or columns to
+    # change the viewport by on either the y or x axis) determined by the offset
+    # (the cursor's y or x offset position.
+    #
+    # @param offset [Fixnum] The cursor's {oy} or {ox} values.
+    # @param dimension [Fixnum] Either the height or width.
+    # @return [Fixnum]
+    def content_offset(offset, dimension)
+      if offset >= dimension && ((offset - dimension) > 0)
+        offset - dimension
+
+      else
+        0
+
+      end
     end
 
     # Return the border associated with the interface we are drawing.
     #
-    # @return [Vedeu::Border|Vedeu::NullBorder]
+    # @return (see Vedeu::Borders#by_name)
     def border
       @border ||= Vedeu.borders.by_name(name)
     end
 
     # Fetch the cursor associated with the interface we are drawing.
     #
-    # @return [Vedeu::Cursor]
+    # @return (see Vedeu::Cursors#by_name)
     def cursor
       @cursor ||= Vedeu.cursors.by_name(name)
     end
 
     # Return the geometry associated with the interface we are drawing.
     #
-    # @return [Vedeu::Geometry|Vedeu::NullGeometry]
+    # @return (see Vedeu::Geometries#by_name)
     def geometry
       @geometry || Vedeu.geometries.by_name(name)
     end

data/lib/vedeu/output/virtual_terminal.rb

@@ -120,4 +120,3 @@ module Vedeu
   end # VirtualTerminal
 
 end # Vedeu
-

data/lib/vedeu/repositories/repositories/borders.rb

@@ -21,14 +21,13 @@ module Vedeu
     end
 
     # @param name [String] The name of the stored border.
-    # @return [Vedeu::Border|Vedeu::NullBorder|NilClass]
+    # @return [Vedeu::Border|Vedeu::NullBorder]
     def by_name(name)
       if registered?(name)
         find(name)
 
-      elsif Vedeu.interfaces.registered?(name)
-        interface = Vedeu.interfaces.find(name)
-        Vedeu::NullBorder.new(interface)
+      else
+        Vedeu::NullBorder.new(name)
 
       end
     end

data/lib/vedeu/repositories/repositories/cursors.rb

@@ -11,7 +11,7 @@ module Vedeu
 
     # @return [Vedeu::Cursor]
     def self.cursor
-      cursors.current
+      cursors.by_name(Vedeu.focus) if Vedeu.focus
     end
 
     # @return [Vedeu::Cursors]
@@ -24,6 +24,18 @@ module Vedeu
       @cursors = Vedeu::Cursors.register_repository(Vedeu::Cursor)
     end
 
+    # @param name [String] The name of the stored cursor.
+    # @return [Vedeu::Cursor]
+    def by_name(name)
+      if registered?(name)
+        find(name)
+
+      else
+        Vedeu::Cursor.new(name: name).store
+
+      end
+    end
+
   end # Cursors
 
 end # Vedeu

data/lib/vedeu/repositories/repositories/geometries.rb

@@ -27,7 +27,7 @@ module Vedeu
         find(name)
 
       else
-        Vedeu::NullGeometry.new
+        Vedeu::NullGeometry.new(name)
 
       end
     end

data/lib/vedeu/support/all.rb

@@ -1,4 +1,5 @@
 require_relative 'common'
+require_relative 'options'
 require_relative 'template'
 require_relative 'terminal'
 require_relative 'trace'

data/lib/vedeu/support/options.rb

@@ -0,0 +1,65 @@
+module Vedeu
+
+  # Converts an options Hash into a class containing methods for each of the
+  # keys, which when called returns the value associated. When the value is
+  # either true or false, an additional predicate method is created.
+  #
+  class Options
+
+    # @!attribute [r] _defined
+    # @return [Array<Symbol>]
+    attr_reader :_defined
+
+    # @param options [Hash]
+    # @return [Vedeu::Options]
+    def self.build(options = {})
+      new(options)._build
+    end
+
+    # @param options [Hash]
+    # @return [Vedeu::Options]
+    def initialize(options = {})
+      @_options = options
+      @_defined = []
+    end
+
+    # @return [Vedeu::Options]
+    def _build
+      _options.each do |name, value|
+        _create_method(name) { value }
+
+        if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          _create_alias("#{name}?", name)
+        end
+      end
+
+      self
+    end
+
+    private
+
+    # @!attribute [r] _options
+    # @return [Hash]
+    attr_reader :_options
+
+    # @param alias_name [String|Symbol]
+    # @param method_name [String|Symbol]
+    # @return [void]
+    def _create_alias(alias_name, method_name)
+      @_defined << alias_name.to_sym
+
+      define_singleton_method(alias_name, method(method_name))
+    end
+
+    # @param name [String|Symbol]
+    # @param block [Proc]
+    # @return [void]
+    def _create_method(name, &block)
+      @_defined << name.to_sym
+
+      self.class.send(:define_method, name, &block)
+    end
+
+  end # Option
+
+end # Vedeu

data/lib/vedeu/support/terminal.rb

@@ -14,10 +14,9 @@ module Vedeu
     # Opens a terminal screen in either `raw` or `cooked` mode. On exit,
     # attempts to restore the screen. See {Vedeu::Terminal#restore_screen}.
     #
-    # @param block [Proc]
     # @raise [InvalidSyntax] The required block was not given.
     # @return [Array]
-    def open(&block)
+    def open
       fail InvalidSyntax, 'block not given' unless block_given?
 
       if raw_mode?
@@ -91,12 +90,11 @@ module Vedeu
       true
     end
 
-    # @param block [Proc]
     # @return [void]
-    def initialize_screen(&block)
+    def initialize_screen
       output(Esc.string('screen_init'))
 
-      yield
+      yield if block_given?
     end
 
     # Clears the entire terminal space.

data/test/lib/vedeu/cursor/cursor_test.rb

@@ -37,11 +37,6 @@ module Vedeu
       it { subject.instance_variable_get('@visible').must_equal(true) }
       it { subject.instance_variable_get('@x').must_equal(19) }
       it { subject.instance_variable_get('@y').must_equal(8) }
-
-      it do
-        subject.instance_variable_get('@position').
-          must_be_instance_of(Vedeu::Position)
-      end
     end
 
     describe '#inspect' do

data/test/lib/vedeu/cursor/move_test.rb

@@ -5,63 +5,65 @@ module Vedeu
   describe Move do
 
     let(:described) { Vedeu::Move }
-    let(:instance)  { described.new(cursor, interface, dy, dx) }
-    let(:cursor)    {
-      Cursor.new(name: 'Move',
-                 ox:    ox,
-                 oy:    oy,
-                 visible: true,
-                 x:     x,
-                 y:     y)
-    }
+    let(:instance)  { described.new(_name, dy, dx) }
+    let(:_name)     { '' }
+    let(:dy)        { 0 }
+    let(:dx)        { 0 }
     let(:ox)        { 0 }
     let(:oy)        { 0 }
     let(:x)         { 1 }
     let(:y)         { 1 }
 
-    let(:interface) {
-      Vedeu.interface 'magnesium' do
-        geometry do
-
-        end
-      end
-    }
-    let(:interface_with_border) {
-      Vedeu.interface 'manganese' do
+    before do
+      Vedeu.borders.reset
+      Vedeu.cursors.reset
+      Vedeu.geometries.reset
+      Vedeu.interfaces.reset
+
+      Vedeu::Cursor.new(name:    'move_with_border',
+                        ox:      ox,
+                        oy:      oy,
+                        visible: true,
+                        x:       x,
+                        y:       y).store
+      Vedeu::Cursor.new(name:    'move_without_border',
+                        ox:      ox,
+                        oy:      oy,
+                        visible: true,
+                        x:       x,
+                        y:       y).store
+      Vedeu.interface 'move_with_border' do
         border do
           # ...
         end
         geometry do
-          height 5
-          width 5
-          x 5
-          y 5
+          x  5
+          xn 10
+          y  5
+          yn 10
         end
       end
-    }
-    let(:interface_without_border) {
-      Vedeu.interface 'meitnerium' do
+      Vedeu.interface 'move_without_border' do
         geometry do
-          height 5
-          width 5
-          x 5
-          y 5
+          x  5
+          xn 10
+          y  5
+          yn 10
         end
       end
-    }
-
-    let(:dy)        { 0 }
-    let(:dx)        { 0 }
-
-    before do
       IO.console.stubs(:winsize).returns([25, 80])
       IO.console.stubs(:print)
     end
+    after do
+      Vedeu.borders.reset
+      Vedeu.cursors.reset
+      Vedeu.geometries.reset
+      Vedeu.interfaces.reset
+    end
 
     describe '#initialize' do
       it { instance.must_be_instance_of(Vedeu::Move) }
-      it { instance.instance_variable_get('@cursor').must_equal(cursor) }
-      it { instance.instance_variable_get('@interface').must_equal(interface) }
+      it { instance.instance_variable_get('@name').must_equal(_name) }
       it { instance.instance_variable_get('@dy').must_equal(dy) }
       it { instance.instance_variable_get('@dx').must_equal(dx) }
     end
@@ -71,10 +73,6 @@ module Vedeu
       let(:_name)     { 'manganese' }
 
       before do
-        Vedeu.interfaces.reset
-        Vedeu.cursors.reset
-
-        interface_with_border
         Vedeu::Cursor.new(name: 'manganese', oy: 2, ox: 3, x: 8, y: 7).store
       end
 
@@ -119,122 +117,117 @@ module Vedeu
     end
 
     describe '.down' do
-      subject { Move.down(cursor, interface) }
+      let(:_name) { 'move_down' }
+
+      subject { Move.down(_name) }
 
       it { subject.must_be_instance_of(Vedeu::Cursor) }
 
       it { subject.y.must_equal(2) }
 
-      context 'when moving, the cursor must be within the boundary of the ' \
-              'interface' do
-        subject { Move.down(cursor, interface_without_border) }
-        let(:y) { 15 }
+      context 'when within the boundary of the interface' do
+        let(:_name) { 'move_without_border' }
+        let(:oy)    { 15 }
 
         it 'does not move past the bottom of the interface' do
-          subject.y.must_equal(6)
+          subject.y.must_equal(10)
         end
       end
 
-      context 'when moving, the cursor must be within the border of the ' \
-              'interface' do
-        subject { Move.down(cursor, interface_with_border) }
-        let(:y)         { 15 }
+      context 'when within the border of the interface' do
+        let(:_name) { 'move_with_border' }
+        let(:oy)    { 15 }
 
         it 'does not move past the bottom border' do
-          subject.y.must_equal(6)
+          subject.y.must_equal(9)
         end
       end
     end
 
     describe '.left' do
-      subject { Move.left(cursor, interface) }
+      let(:_name) { 'move_left' }
+
+      subject { Move.left(_name) }
 
       it { subject.must_be_instance_of(Vedeu::Cursor) }
 
       it { subject.x.must_equal(1) }
 
-      context 'when moving, the cursor must be within the boundary of the ' \
-              'interface' do
-        subject { Move.left(cursor, interface_without_border) }
-        let(:x)         { 3 }
+      context 'when within the boundary of the interface' do
+        let(:_name) { 'move_without_border' }
 
         it 'does not move past the left of the interface' do
-          subject.x.must_equal(3)
+          subject.x.must_equal(5)
         end
       end
 
-      context 'when moving, the cursor must be within the border of the ' \
-              'interface' do
-        subject { Move.left(cursor, interface_with_border) }
-        let(:x)         { 4 }
+      context 'when within the border of the interface' do
+        let(:_name) { 'move_with_border' }
 
         it 'does not move past the left border' do
-          subject.x.must_equal(4)
+          subject.x.must_equal(6)
         end
       end
     end
 
     describe '.right' do
-      subject { Move.right(cursor, interface) }
+      let(:_name) { 'move_right' }
+
+      subject { Move.right(_name) }
 
       it { subject.must_be_instance_of(Vedeu::Cursor) }
 
       it { subject.x.must_equal(2) }
 
-      context 'when moving, the cursor must be within the boundary of the ' \
-              'interface' do
-        subject { Move.right(cursor, interface_without_border) }
-        let(:x)         { 14 }
+      context 'when within the boundary of the interface' do
+        let(:_name) { 'move_without_border' }
+        let(:ox)    { 15 }
 
         it 'does not move past the right of the interface' do
-          subject.x.must_equal(6)
+          subject.x.must_equal(10)
         end
       end
 
-      context 'when moving, the cursor must be within the border of the ' \
-              'interface' do
-        subject { Move.right(cursor, interface_with_border) }
-
-        let(:x)         { 14 }
+      context 'when within the border of the interface' do
+        let(:_name) { 'move_with_border' }
+        let(:ox)    { 15 }
 
         it 'does not move past the right border' do
-          subject.x.must_equal(6)
+          subject.x.must_equal(9)
         end
       end
     end
 
     describe '.up' do
-      subject { Move.up(cursor, interface) }
+      let(:_name) { 'move_up' }
+
+      subject { Move.up(_name) }
 
       it { subject.must_be_instance_of(Vedeu::Cursor) }
 
       it { subject.y.must_equal(1) }
 
-      context 'when moving, the cursor must be within the boundary of the ' \
-              'interface' do
-        subject { Move.up(cursor, interface_without_border) }
-
-        let(:y)         { 3 }
+      context 'when within the boundary of the interface' do
+        let(:_name) { 'move_without_border' }
 
         it 'does not move past the top of the interface' do
-          subject.y.must_equal(3)
+          subject.y.must_equal(5)
         end
       end
 
-      context 'when moving, the cursor must be within the border of the ' \
-              'interface' do
-        subject { Move.up(cursor, interface_with_border) }
-
-        let(:y)         { 3 }
+      context 'when within the border of the interface' do
+        let(:_name) { 'move_with_border' }
 
         it 'does not move past the top border' do
-          subject.y.must_equal(3)
+          subject.y.must_equal(6)
         end
       end
     end
 
     describe '#origin' do
-      subject { Move.origin(cursor, interface) }
+      let(:_name) { 'move_origin' }
+
+      subject { Move.origin(_name) }
 
       it { subject.must_be_instance_of(Vedeu::Cursor) }
 
@@ -244,14 +237,14 @@ module Vedeu
       end
 
       context 'within the boundary of the interface' do
-        subject { Move.origin(cursor, interface_without_border) }
+        let(:_name) { 'move_without_border' }
 
         it { subject.x.must_equal(5) }
         it { subject.y.must_equal(5) }
       end
 
       context 'within the border of the interface' do
-        subject { Move.origin(cursor, interface_with_border) }
+        let(:_name) { 'move_with_border' }
 
         it { subject.x.must_equal(6) }
         it { subject.y.must_equal(6) }
@@ -259,7 +252,9 @@ module Vedeu
     end
 
     describe '#move' do
-      subject { Move.new(cursor, interface, dy, dx).move }
+      let(:_name) { 'move_move' }
+
+      subject { Move.new(_name, dy, dx).move }
 
       it { subject.must_be_instance_of(Vedeu::Cursor) }
     end