vedeu 0.4.13 → 0.4.14

data/test/lib/vedeu/storage/store_test.rb

@@ -0,0 +1,123 @@
+require 'test_helper'
+
+module Vedeu
+
+  class StoreTestClass
+    include Vedeu::Store
+
+    attr_reader :model
+
+    def initialize(model = nil, storage = {})
+      @model   = model
+      @storage = storage
+    end
+
+    private
+
+    def in_memory
+      {}
+    end
+  end
+
+  describe Store do
+
+    let(:described) { Vedeu::Store }
+    let(:instance)  { Vedeu::StoreTestClass.new(model, storage) }
+    let(:model)     {}
+    let(:storage)   {}
+
+    describe 'alias methods' do
+      it { instance.must_respond_to(:registered?) }
+    end
+
+    describe '#each' do
+      subject { instance.each }
+
+      it { subject.must_be_instance_of(Enumerator) }
+    end
+
+    describe '#empty?' do
+      subject { instance.empty? }
+
+      context 'when empty' do
+        it { subject.must_equal(true) }
+      end
+
+      context 'when not empty' do
+        let(:storage) { [:item] }
+
+        it { subject.must_equal(false) }
+      end
+    end
+
+    describe '#exists?' do
+      let(:_name) {}
+
+      subject { instance.exists?(_name) }
+
+      context 'when empty' do
+        let(:_name) { 'terbium' }
+
+        it { subject.must_equal(false) }
+      end
+
+      context 'with no name' do
+        it { subject.must_equal(false) }
+      end
+
+      context 'with empty name' do
+        let(:_name) { '' }
+
+        it { subject.must_equal(false) }
+      end
+
+      context 'when the model does not exist' do
+        let(:storage) { { 'samarium' => [:some_model_data] } }
+        let(:_name)   { 'terbium' }
+
+        it { subject.must_equal(false) }
+      end
+
+      context 'when the model exists' do
+        let(:storage) { { 'samarium' => [:some_model_data] } }
+        let(:_name)   { 'samarium' }
+
+        it { subject.must_equal(true) }
+      end
+    end
+
+    describe '#reset' do
+      it 'returns a Hash' do
+        instance.reset.must_be_instance_of(Hash)
+      end
+
+      it 'resets the repository' do
+        instance.reset.must_equal({})
+      end
+    end
+
+    describe '#size' do
+      subject { instance.size }
+
+      context 'when empty' do
+        it { subject.must_equal(0) }
+      end
+
+      context 'when not empty' do
+        let(:storage) { [:item] }
+
+        it { subject.must_equal(1) }
+      end
+    end
+
+    describe '#storage' do
+      subject { instance.storage }
+
+      it { subject.must_equal({}) }
+
+      it { instance.must_respond_to(:all) }
+    end
+
+  end # Store
+
+end # Vedeu

data/test/lib/vedeu/support/common_test.rb

@@ -45,15 +45,6 @@ module Vedeu
       end
     end
 
-    describe '#to_sentence' do
-      let(:array) { ['hydrogen', 'helium', 'lithium'] }
-
-      subject { described.to_sentence(array) }
-
-      it { subject.must_be_instance_of(String) }
-      it { subject.must_equal('hydrogen, helium and lithium') }
-    end
-
   end # Common
 
 end # Vedeu

data/test/lib/vedeu/support/terminal_test.rb

@@ -35,7 +35,7 @@ module Vedeu
         Configuration.stub(:terminal_mode, :raw) do
           capture_io do
             Terminal.open do
-              print "Hello from raw mode!"
+              print 'Hello from raw mode!'
             end
           end.must_equal(['Hello from raw mode!', ''])
         end
@@ -45,7 +45,7 @@ module Vedeu
         Configuration.stub(:terminal_mode, :cooked) do
           capture_io do
             Terminal.open do
-              print "Hello from cooked mode!"
+              print 'Hello from cooked mode!'
             end
           end.must_equal(['Hello from cooked mode!', ''])
         end
@@ -53,6 +53,8 @@ module Vedeu
     end
 
     describe '.input' do
+      subject { Terminal.input }
+
       context 'when the terminal is in cooked mode' do
         let(:mode)  { :cooked }
         let(:input) { "Some input\r\n" }
@@ -62,8 +64,6 @@ module Vedeu
           IO.console.stubs(:gets).returns(input)
         end
 
-        subject { Terminal.input }
-
         it { subject.must_equal('Some input') }
       end
 
@@ -78,8 +78,6 @@ module Vedeu
           IO.console.stubs(:read_nonblock)
         end
 
-        subject { Terminal.input }
-
         it { subject.must_be_instance_of(String) }
       end
     end
@@ -95,20 +93,22 @@ module Vedeu
       context 'when there are multiple values' do
         let(:value) { ['Some output...', 'more output...', 'even more...'] }
 
-        it { subject.must_equal(['Some output...', 'more output...', 'even more...']) }
+        it { subject.must_equal(['Some output...',
+                                 'more output...',
+                                 'even more...']) }
       end
     end
 
     describe '.resize' do
       before { Vedeu.interfaces.reset }
 
-      subject { Terminal.resize }
+      subject { described.resize }
 
       it { subject.must_be_instance_of(TrueClass) }
     end
 
     describe '.clear' do
-      subject { Terminal.clear }
+      subject { described.clear }
 
       it 'clears the screen' do
         subject.must_equal(["\e[39m\e[49m\e[2J"])
@@ -116,138 +116,161 @@ module Vedeu
     end
 
     describe '.set_cursor_mode' do
+      subject { described.set_cursor_mode }
+
       it 'shows the cursor in cooked mode' do
-        Terminal.cooked_mode!
-        Terminal.set_cursor_mode.must_equal(["\e[?25h"])
+        described.cooked_mode!
+        subject.must_equal(["\e[?25h"])
       end
 
       it 'hides the cursor in raw mode' do
-        Terminal.raw_mode!
-        Terminal.set_cursor_mode.must_equal(nil)
+        described.raw_mode!
+        subject.must_equal(nil)
       end
     end
 
     describe '.raw_mode?' do
+      subject { described.raw_mode? }
+
       it 'returns true if the terminal is in raw mode' do
-        Terminal.raw_mode!
-        Terminal.raw_mode?.must_equal(true)
+        described.raw_mode!
+        subject.must_equal(true)
       end
 
       it 'returns false if the terminal is not in raw mode' do
-        Terminal.cooked_mode!
-        Terminal.raw_mode?.must_equal(false)
+        described.cooked_mode!
+        subject.must_equal(false)
       end
     end
 
     describe '.cooked_mode?' do
+      subject { described.cooked_mode? }
+
       it 'returns true if the terminal is in cooked mode' do
-        Terminal.cooked_mode!
-        Terminal.cooked_mode?.must_equal(true)
+        described.cooked_mode!
+        subject.must_equal(true)
       end
 
       it 'returns false if the terminal is not in cooked mode' do
-        Terminal.raw_mode!
-        Terminal.cooked_mode?.must_equal(false)
+        described.raw_mode!
+        subject.must_equal(false)
       end
     end
 
     describe '.switch_mode!' do
+      subject { described.switch_mode! }
+
       it 'returns a Symbol' do
-        Terminal.switch_mode!.must_be_instance_of(Symbol)
+        subject.must_be_instance_of(Symbol)
       end
 
       it 'returns :cooked if previously :raw' do
-        Terminal.raw_mode!
-        Terminal.switch_mode!.must_equal(:cooked)
+        described.raw_mode!
+        subject.must_equal(:cooked)
       end
 
       it 'returns :raw if previously :cooked' do
-        Terminal.cooked_mode!
-        Terminal.switch_mode!.must_equal(:raw)
+        described.cooked_mode!
+        subject.must_equal(:raw)
       end
     end
 
     describe '.mode' do
+      subject { described.mode }
+
       before do
         Configuration.stubs(:terminal_mode).returns(:raw)
         Terminal.switch_mode! if Terminal.mode == :cooked
       end
 
+      it { subject.must_be_instance_of(Symbol) }
+
       it 'returns the configured terminal mode' do
-        Terminal.mode.must_be_instance_of(Symbol)
-        Terminal.mode.must_equal(:raw)
+        subject.must_equal(:raw)
       end
     end
 
     describe '.centre' do
+      subject { described.centre }
+
+      it { subject.must_be_instance_of(Array) }
+
       it 'returns the centre point on the terminal' do
-        Terminal.centre.must_be_instance_of(Array)
-        Terminal.centre.must_equal([12, 40])
+        subject.must_equal([12, 40])
       end
     end
 
     describe '.centre_y' do
+      subject { described.centre_y }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
       it 'returns the centre `y` point on the terminal' do
-        Terminal.centre_y.must_be_instance_of(Fixnum)
-        Terminal.centre_y.must_equal(12)
+        subject.must_equal(12)
       end
     end
 
     describe '.centre_x' do
+      subject { described.centre_x }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
       it 'returns the centre `x` point on the terminal' do
-        Terminal.centre_x.must_be_instance_of(Fixnum)
-        Terminal.centre_x.must_equal(40)
+        subject.must_equal(40)
       end
     end
 
     describe '.origin' do
-      it 'returns 1' do
-        Terminal.origin.must_be_instance_of(Fixnum)
-        Terminal.origin.must_equal(1)
-      end
+      subject { Terminal.origin }
 
-      it { Terminal.must_respond_to(:x) }
-      it { Terminal.must_respond_to(:y) }
+      it { subject.must_be_instance_of(Fixnum) }
+
+      it { subject.must_equal(1) }
     end
 
     describe '.width' do
+      subject { Terminal.width }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
       context 'via method' do
-        it 'returns the width of the terminal' do
-          Terminal.width.must_be_instance_of(Fixnum)
-          Terminal.width.must_equal(80)
+        it 'returns the width' do
+          subject.must_equal(80)
         end
       end
 
       context 'via API' do
-        it 'returns the width of the terminal' do
+        it 'returns the width' do
           Vedeu.width.must_equal(80)
         end
       end
-
-      it { Terminal.must_respond_to(:xn) }
     end
 
     describe '.height' do
+      subject { Terminal.height }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
       context 'via method' do
-        it 'returns the height of the terminal' do
-          Terminal.height.must_be_instance_of(Fixnum)
-          Terminal.height.must_equal(25)
+        it 'returns the height' do
+          subject.must_equal(25)
         end
       end
 
       context 'via API' do
-        it 'returns the height of the terminal' do
+        it 'returns the height' do
           Vedeu.height.must_equal(25)
         end
       end
-
-      it { Terminal.must_respond_to(:yn) }
     end
 
     describe '.size' do
-      it 'returns the width and height of the terminal' do
-        Terminal.size.must_be_instance_of(Array)
-        Terminal.size.must_equal([25, 80])
+      subject { Terminal.size }
+
+      it { subject.must_be_instance_of(Array) }
+
+      it 'returns the width and height' do
+        subject.must_equal([25, 80])
       end
     end
 

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

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+module Vedeu
+
+  class VisibilityTestModel
+    attr_accessor :visible
+    alias_method :visible?, :visible
+
+    def initialize(visible = true)
+      @visible = visible
+    end
+
+    def store
+      self
+    end
+  end
+
+  describe Visibility do
+
+    let(:described) { Vedeu::Visibility }
+    let(:instance)  { described.new(model) }
+    let(:model)     { VisibilityTestModel.new(visible) }
+    let(:visible)   { true }
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(Vedeu::Visibility) }
+      it { instance.instance_variable_get('@model').must_equal(model) }
+    end
+
+    describe '.show' do
+      subject { described.show(model) }
+
+      it { subject.must_equal(model) }
+
+      it { subject; instance.state.must_equal(:visible) }
+    end
+
+    describe '.hide' do
+      subject { described.hide(model) }
+
+      it { subject.must_equal(model) }
+
+      it { subject; instance.state.must_equal(:invisible) }
+    end
+
+    describe '.toggle' do
+      subject { described.toggle(model) }
+
+      it { subject.must_equal(model) }
+
+      context 'when the model is visible' do
+        it { subject; instance.state.must_equal(:invisible) }
+      end
+
+      context 'when the model is not visible' do
+        let(:visible) { false }
+
+        it { subject; instance.state.must_equal(:visible) }
+      end
+    end
+
+    describe '#state' do
+      subject { instance.state }
+
+      it { subject.must_be_instance_of(Symbol) }
+
+      context 'when the model is visible' do
+        it { subject.must_equal(:visible) }
+      end
+
+      context 'when the model is not visible' do
+        let(:visible) { false }
+
+        it { subject.must_equal(:invisible) }
+      end
+    end
+
+  end # Visibility
+
+end # Vedeu

data/test/test_helper.rb

@@ -37,6 +37,17 @@ require 'mocha/setup'
 require 'vedeu'
 require 'support/helpers/all'
 
+# require 'minitest/reporters'
+# Minitest::Reporters.use!(
+#  # commented out by default (makes tests slower)
+#  # Minitest::Reporters::DefaultReporter.new({ color: true, slow_count: 5 }),
+#  # Minitest::Reporters::SpecReporter.new
+# )
+
+# trace method execution with (optionally) local variables
+# require 'vedeu/support/log'
+# Vedeu::Trace.call({ watched: 'call', klass: /^Vedeu/ })
+
 def test_configuration
   Vedeu::Configuration.reset!
 
@@ -50,17 +61,8 @@ def test_configuration
      # will be logged, otherwise every `Vedeu.log` will be logged.
     log '/tmp/vedeu_test_helper.log'
   end
+
+  Vedeu::Repositories.reset!
 end
 
 test_configuration
-
-# require 'minitest/reporters'
-# Minitest::Reporters.use!(
-#   # commented out by default (makes tests slower)
-#   # Minitest::Reporters::DefaultReporter.new({ color: true, slow_count: 5 }),
-#   # Minitest::Reporters::SpecReporter.new
-# )
-
-# trace method execution with (optionally) local variables
-# require 'vedeu/support/log'
-# Vedeu::Trace.call({ watched: 'call', klass: /^Vedeu/ })

data/vedeu.gemspec

@@ -4,11 +4,12 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'vedeu'
-  spec.version       = '0.4.13'
+  spec.version       = '0.4.14'
   spec.authors       = ['Gavin Laking']
   spec.email         = ['gavinlaking@gmail.com']
-  spec.summary       = %q{A terminal case of wonderland.}
-  spec.description   = %q{A GUI framework written in Ruby for building terminal/console applications.}
+  spec.summary       = 'A terminal case of wonderland.'
+  spec.description   = 'A GUI framework written in Ruby for building ' \
+                       'terminal/console applications.'
   spec.homepage      = 'https://github.com/gavinlaking/vedeu'
   spec.license       = 'MIT'