vedeu 0.4.13 → 0.4.14

data/lib/vedeu/repositories/collections.rb

@@ -1,41 +0,0 @@
-require 'vedeu/repositories/collection'
-
-module Vedeu
-
-  # A collection of {Vedeu::Char} instances.
-  #
-  class Chars < Vedeu::Collection
-
-  end # Chars
-
-  # A collection of {Vedeu::Event} instances.
-  #
-  class Events < Vedeu::Collection
-
-  end # Events
-
-  # A collection of {Vedeu::Interface} instances.
-  #
-  class Interfaces < Vedeu::Collection
-
-  end # Interfaces
-
-  # A collection of {Vedeu::Key} instances.
-  #
-  class Keys < Vedeu::Collection
-
-  end # Keys
-
-  # A collection of {Vedeu::Line} instances.
-  #
-  class Lines < Vedeu::Collection
-
-  end # Lines
-
-  # A collection of {Vedeu::Stream} instances.
-  #
-  class Streams < Vedeu::Collection
-
-  end # Streams
-
-end # Vedeu

data/lib/vedeu/support/coercions.rb

@@ -1,60 +0,0 @@
-require 'vedeu/support/common'
-
-module Vedeu
-
-  # Provides means to convert attributes into the correct model.
-  #
-  module Coercions
-
-    include Vedeu::Common
-
-    # Produces new objects of the correct class from the value, ignores objects
-    # that have already been coerced.
-    #
-    # @param value [Object|NilClass]
-    # @return [Object]
-    def coerce(value)
-      if value.nil?
-        new
-
-      elsif value.is_a?(self)
-        value
-
-      else
-        new(value)
-
-      end
-    end
-
-    # Produces new objects of the correct class from attributes hashes,
-    # ignores objects that have already been coerced.
-    #
-    # @param values [Array|Hash]
-    # @return [Array]
-    def coercer(values)
-      return [] unless defined_value?(values)
-
-      [values].flatten.map do |value|
-        if value.is_a?(self)
-          value
-
-        else
-          new(value)
-
-        end
-      end
-    end
-
-    # Whenever this module {Vedeu::Coercions} is included in another class or
-    # module, make its methods into class methods, so they may be called
-    # directly.
-    #
-    # @param receiver [Class] The class in which this module is included.
-    # @return [void]
-    def self.included(receiver)
-      receiver.extend(self)
-    end
-
-  end # Coercions
-
-end # Vedeu

data/lib/vedeu/support/sentence.rb

@@ -1,91 +0,0 @@
-module Vedeu
-
-  # Take a collection of words (elements) and form a sentence from them.
-  #
-  # @example
-  #   elements = ['Hydrogen', 'Helium', 'Lithium']
-  #   Vedeu::Sentence.construct(elements) # => 'Hydrogen, Helium and Lithium'
-  #
-  class Sentence
-
-    # @param elements [Array]
-    # @param label [String]
-    # @return [String]
-    def self.construct(elements, label = 'elements')
-      new(elements, label).construct
-    end
-
-    # Returns a new instance of Vedeu::Sentence.
-    #
-    # @param elements [Array]
-    # @param label [String]
-    # @return [Vedeu::Sentence]
-    def initialize(elements, label)
-      @elements, @label = elements, label
-    end
-
-    # @return [String]
-    def construct
-      if one?
-        first
-
-      elsif two?
-        elements.join(' and ')
-
-      elsif many?
-        [but_last, last].join(' and ')
-
-      else
-        "No #{label} have been assigned."
-
-      end
-    end
-
-    private
-
-    # @!attribute [r] elements
-    # @return [Array]
-    attr_reader :elements
-
-    # @!attribute [r] label
-    # @return [String]
-    attr_reader :label
-
-    # @return [Boolean]
-    def one?
-      count == 1
-    end
-
-    # @return [Boolean]
-    def two?
-      count == 2
-    end
-
-    # @return [Boolean]
-    def many?
-      count > 2
-    end
-
-    # @return [String]
-    def but_last
-      elements[0...-1].join(', ')
-    end
-
-    # @return [String]
-    def first
-      elements.first
-    end
-
-    # @return [String]
-    def last
-      elements[-1]
-    end
-
-    # @return [Fixnum]
-    def count
-      elements.size
-    end
-
-  end # Sentence
-
-end # Vedeu

data/lib/vedeu/support/visible.rb

@@ -1,90 +0,0 @@
-require 'vedeu/output/esc'
-
-module Vedeu
-
-  # Represents the concept of a visible or invisible attribute.
-  #
-  class Visible
-
-    # @param value [Boolean|Symbol]
-    # @return [Visible]
-    def self.coerce(value)
-      if value.is_a?(self)
-        value
-
-      else
-        new(value)
-
-      end
-    end
-
-    # Returns a new instance of Vedeu::Visible
-    #
-    # @param visible [Boolean|Symbol]
-    # @return [Visible]
-    def initialize(visible = nil)
-      @visible = visible
-    end
-
-    # @return [String]
-    def to_s
-      visible? ? 'visible' : 'invisible'
-    end
-
-    # @return [String]
-    def cursor
-      if visible?
-        Vedeu::Esc.string('show_cursor')
-
-      else
-        Vedeu::Esc.string('hide_cursor')
-
-      end
-    end
-
-    # Returns a boolean indicating whether the instance is visible.
-    #
-    # @return [Boolean]
-    def visible?
-      visible
-    end
-
-    # Returns a boolean indicating whether the instance is invisible.
-    #
-    # @return [Boolean]
-    def invisible?
-      !visible
-    end
-
-    # @return [Visible]
-    def hide
-      Vedeu::Visible.new(false)
-    end
-
-    # @return [Visible]
-    def show
-      Vedeu::Visible.new(true)
-    end
-
-    # @return [Visible]
-    def toggle
-      visible? ? hide : show
-    end
-
-    # @return [Boolean]
-    def visible
-      if @visible == :hide || @visible == false
-        false
-
-      elsif @visible == :show || @visible == true
-        true
-
-      else
-        !!@visible
-
-      end
-    end
-
-  end # Visible
-
-end # Vedeu

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

@@ -1,63 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Toggle do
-
-    let(:described) { Toggle.new(cursor) }
-    let(:cursor)    { Cursor.new({ name: 'vanadium',
-                                   ox: 1,
-                                   oy: 1,
-                                   state: state,
-                                   x: 1,
-                                   y: 1 }) }
-    let(:state)     { true }
-
-    describe '#initialize' do
-      it { described.must_be_instance_of(Toggle) }
-      it { described.instance_variable_get('@cursor').must_equal(cursor) }
-    end
-
-    describe '.hide' do
-      subject { Toggle.hide(cursor) }
-
-      it { subject.must_be_instance_of(Cursor) }
-
-      context 'when the cursor is visible' do
-        it 'returns a new cursor' do
-          subject.wont_equal(cursor)
-        end
-      end
-
-      context 'when the cursor is invisible' do
-        let(:state) { false }
-
-        it 'returns the cursor' do
-          subject.must_equal(cursor)
-        end
-      end
-    end
-
-    describe '.show' do
-      subject { Toggle.show(cursor) }
-
-      it { subject.must_be_instance_of(Cursor) }
-
-      context 'when the cursor is visible' do
-        it 'returns the cursor' do
-          subject.must_equal(cursor)
-        end
-      end
-
-      context 'when the cursor is invisible' do
-        let(:state) { false }
-
-        it 'returns a new cursor' do
-          subject.wont_equal(cursor)
-        end
-      end
-    end
-
-  end # Toggle
-
-end # Vedeu

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

@@ -1,58 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Centre do
-
-    let(:described)  { Vedeu::Centre }
-    let(:instance)   { described.new(attributes) }
-    let(:attributes) {
-      {
-        v:     v,
-        vn:    vn,
-        value: value,
-      }
-    }
-    let(:v)     { 2 }
-    let(:vn)    { 47 }
-    let(:value) { 30 }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Vedeu::Centre) }
-      it { instance.instance_variable_get('@v').must_equal(v) }
-      it { instance.instance_variable_get('@vn').must_equal(vn) }
-      it { instance.instance_variable_get('@value').must_equal(value) }
-    end
-
-    describe '#centre' do
-      subject { instance.centre }
-
-      it { subject.must_be_instance_of(Fixnum) }
-
-      context 'when the value is given' do
-        it { subject.must_equal(15) }
-      end
-
-      context 'when the value is not given' do
-        let(:value) {}
-
-        it { subject.must_equal(24) }
-
-        context 'when either v or vn is missing' do
-          let(:vn) {}
-
-          it { proc { subject }.must_raise(InvalidSyntax) }
-        end
-
-        context 'when vn < v' do
-          let(:vn) { 15 }
-          let(:v)  { 32 }
-
-          it { proc { subject }.must_raise(InvalidSyntax) }
-        end
-      end
-    end
-
-  end # Centre
-
-end # Vedeu

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

@@ -1,98 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Content do
-
-    let(:described) { Vedeu::Content }
-    let(:instance)  { described.new(interface) }
-    let(:interface) {
-      Vedeu.interface 'content_geometry' do
-        geometry do
-          height 3
-          width  5
-        end
-      end
-    }
-    let(:lines) { [] }
-
-    before do
-      Vedeu.interfaces.reset
-      interface.stubs(:lines).returns(lines)
-    end
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@interface').must_equal(interface) }
-    end
-
-    describe '#yn' do
-      subject { instance.yn }
-
-      it { subject.must_be_instance_of(Fixnum) }
-
-      context 'when the interface has content' do
-        context 'when there is more lines than height' do
-          let(:lines) {
-            [
-              [:line_1],
-              [:line_2],
-              [:line_3],
-              [:line_4]
-            ]
-          }
-
-          it { subject.must_equal(4) }
-        end
-
-        context 'when there is less lines than height' do
-          it { subject.must_equal(3) }
-        end
-      end
-
-      context 'when the interface does not have content' do
-        it { subject.must_equal(3) }
-      end
-    end
-
-    describe '#xn' do
-      subject { instance.xn }
-
-      it { subject.must_be_instance_of(Fixnum) }
-
-      context 'when the interface has content' do
-        context 'when there are more characters than width' do
-          let(:lines) {
-            [
-              ['S', 'o', 'm', 'e', ' ', 't', 'e', 'x', 't', '.'],
-              ['S', 'o', 'm', 'e'],
-              ['S', 'o', 'm', 'e', ' ', 't', 'e', 'x', 't', '.', '.', '.'],
-              ['S', 'o', 'm', 'e', ' ', 't', 'e'],
-            ]
-          }
-
-          it { subject.must_equal(12) }
-        end
-
-        context 'when there are less characters than width' do
-          let(:lines) {
-            [
-              ['S', 'o', 'm', 'e'],
-              ['S', 'o', 'm', 'e'],
-              ['S', 'o', 'm', 'e'],
-              ['S', 'o', 'm', 'e'],
-            ]
-          }
-
-          it { subject.must_equal(5) }
-        end
-      end
-
-      context 'when the interface does not have content' do
-        it { subject.must_equal(5) }
-      end
-    end
-
-  end # Content
-
-end # Vedeu

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

@@ -1,30 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Limit do
-
-    let(:described) { Vedeu::Limit }
-    let(:instance)  { described.new(v, vn, max, min) }
-    let(:v)         {}
-    let(:vn)        {}
-    let(:max)       {}
-    let(:min)       { 2 }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(Vedeu::Limit) }
-      it { instance.instance_variable_get('@v').must_equal(v) }
-      it { instance.instance_variable_get('@vn').must_equal(vn) }
-      it { instance.instance_variable_get('@max').must_equal(max) }
-      it { instance.instance_variable_get('@min').must_equal(min) }
-
-      context 'when min is nil' do
-        let(:min) {}
-
-        it { instance.instance_variable_get('@min').must_equal(1) }
-      end
-    end
-
-  end # Limit
-
-end # Vedeu

data/test/lib/vedeu/output/compositor_test.rb

@@ -1,48 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  # TODO: Leak detected. (GL 2015-01-28)
-
-  describe Compositor do
-
-    let(:described) { Vedeu::Compositor }
-    let(:instance)  { described.new(_name) }
-    let(:_name)     { 'compositor' }
-    let(:buffer)    { Buffer.new(_name, interface) }
-    let(:interface) {
-      Vedeu.interface(_name) do
-        border!
-        geometry do
-          height 5
-          width  10
-        end
-        lines do
-          line 'Some text.'
-        end
-      end
-    }
-
-    before do
-      IO.console.stubs(:print)
-
-      Vedeu.buffers.reset
-      Vedeu.interfaces.reset
-      Buffer.new(_name, interface).store
-    end
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@name').must_equal(_name) }
-    end
-
-    describe '.compose' do
-      subject { described.compose(_name) }
-
-      it { subject.must_be_instance_of(Array) }
-      it { subject.first.must_be_instance_of(Vedeu::Interface) }
-    end
-
-  end # Compositor
-
-end # Vedeu

data/test/lib/vedeu/repositories/all_test.rb

@@ -1,135 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Borders do
-
-    let(:described) { Vedeu::Borders }
-
-    describe '.borders' do
-      subject { described.borders }
-
-      it { subject.must_be_instance_of(described) }
-    end
-
-  end # Borders
-
-  describe Buffers do
-
-    let(:described) { Vedeu::Buffers }
-
-    describe '.buffers' do
-      subject { described.buffers }
-
-      it { subject.must_be_instance_of(described) }
-    end
-
-  end # Buffers
-
-  describe Cursors do
-
-    let(:described) { Vedeu::Cursors }
-
-    describe '.cursors' do
-      subject { described.cursors }
-
-      it { subject.must_be_instance_of(described) }
-    end
-
-    describe '.cursor' do
-      subject { Vedeu.cursor }
-
-      context 'when there are cursors are defined' do
-        before do
-          Vedeu::Focus.add('Vedeu.cursor')
-          Vedeu::Cursor.new({ name: 'Vedeu.cursor' }).store
-        end
-
-        it { subject.must_be_instance_of(Vedeu::Cursor) }
-      end
-
-      context 'when there are no cursors defined' do
-        before do
-          Vedeu::Focus.reset
-          Vedeu.cursors.reset
-        end
-
-        it { subject.must_be_instance_of(NilClass) }
-      end
-    end
-
-  end # Cursors
-
-  describe EventsRepository do
-
-    let(:described) { Vedeu::EventsRepository }
-
-    describe '.events' do
-      subject { described.events }
-
-      it { subject.must_be_instance_of(described) }
-    end
-
-  end # EventsRepository
-
-  describe Geometries do
-
-    let(:described) { Vedeu::Geometries }
-
-    describe '.geometries' do
-      subject { described.geometries }
-
-      it { subject.must_be_instance_of(described) }
-    end
-
-  end # Geometries
-
-  describe Groups do
-
-    let(:described) { Vedeu::Groups }
-
-    describe '.groups' do
-      subject { described.groups }
-
-      it { subject.must_be_instance_of(described) }
-    end
-
-  end # Groups
-
-  describe InterfacesRepository do
-
-    let(:described) { Vedeu::InterfacesRepository }
-
-    describe '.interfaces' do
-      subject { described.interfaces }
-
-      it { subject.must_be_instance_of(described) }
-    end
-
-  end # InterfacesRepository
-
-  describe Keymaps do
-
-    let(:described) { Vedeu::Keymaps }
-
-    describe '.keymaps' do
-      subject { described.keymaps }
-
-      it { subject.must_be_instance_of(described) }
-    end
-
-  end # Keymaps
-
-  describe Menus do
-
-    let(:described) { Vedeu::Menus }
-
-    describe '.menus' do
-      subject { described.menus }
-
-      it { subject.must_be_instance_of(described) }
-    end
-
-  end # Menus
-
-end # Vedeu