vedeu 0.6.9 → 0.6.10

data/lib/vedeu/terminal/content.rb

@@ -1,88 +0,0 @@
-module Vedeu
-
-  module Terminal
-
-    # A permanent copy of the terminal output.
-    #
-    module Content
-
-      include Vedeu::Common
-      extend self
-
-      # @param char [Vedeu::Views::Char]
-      # @return [Boolean]
-      def valid?(char)
-        char.respond_to?(:position) &&
-          present?(char.position.y) &&
-          present?(char.position.x)
-      end
-
-      # @param char [Vedeu::Views::Char]
-      # @return [Vedeu::Views::Char]
-      def store(char)
-        # value = {}
-        # value[:background] = char.background.to_s if char.background
-        # value[:foreground] = char.foreground.to_s if char.foreground
-        # value[:style]      = char.style.to_s      if char.style
-        # value[:value]      = char.value           if char.value
-        # value[:x]          = char.position.x      if char.position.x
-        # value[:y]          = char.position.y      if char.position.y
-
-        storage[char.position.y][char.position.x] = char.value if valid?(char)
-
-        char
-      end
-
-      # @param chars [Array<Vedeu::Views::Char>]
-      # @return [Array<Vedeu::Views::Char>]
-      def stores(chars)
-        Array(chars).flatten.map { |char| store(char) }
-      end
-
-      # @return [Hash<String => String>|NilClass]
-      def write
-        filename = "/tmp/vedeu/content_#{Time.now.to_f}"
-
-        File.write(filename, storage.inspect) if Vedeu::Configuration.log?
-      end
-
-      # @return [Array<String>]
-      def reprocess
-        out = []
-        storage.each do |y, line|
-          line.each do |x, value|
-            out << Vedeu::Views::Char.new(position: [y, x], value: value).to_s
-          end
-        end
-
-        Vedeu::Terminal.clear
-
-        Vedeu::Terminal.output(out.join)
-      end
-
-      # @return [Hash]
-      def reset
-        @storage = in_memory
-      end
-
-      private
-
-      # Returns an empty collection ready for the storing terminal content.
-      #
-      # @return [Hash]
-      def in_memory
-        Hash.new { |h, k| h[k] = {} }
-      end
-
-      # Access to the storage for this repository.
-      #
-      # @return [Array]
-      def storage
-        @storage ||= in_memory
-      end
-
-    end # Content
-
-  end # Terminal
-
-end # Vedeu

data/test/lib/vedeu/api_test.rb

@@ -1,58 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe API do
-
-    it { Vedeu.must_respond_to(:bind) }
-    it { Vedeu.must_respond_to(:bind_alias) }
-    it { Vedeu.must_respond_to(:border) }
-    it { Vedeu.must_respond_to(:bound?) }
-    it { Vedeu.must_respond_to(:clear) }
-    it { Vedeu.must_respond_to(:clear_by_group) }
-    it { Vedeu.must_respond_to(:clear_by_name) }
-    it { Vedeu.must_respond_to(:configuration) }
-    it { Vedeu.must_respond_to(:configure) }
-    it { Vedeu.must_respond_to(:cursor) }
-    it { Vedeu.must_respond_to(:drb_restart) }
-    it { Vedeu.must_respond_to(:drb_start) }
-    it { Vedeu.must_respond_to(:drb_status) }
-    it { Vedeu.must_respond_to(:drb_stop) }
-    it { Vedeu.must_respond_to(:events) }
-    it { Vedeu.must_respond_to(:exit) }
-    it { Vedeu.must_respond_to(:focus) }
-    it { Vedeu.must_respond_to(:focus_by_name) }
-    it { Vedeu.must_respond_to(:focus_next) }
-    it { Vedeu.must_respond_to(:focus_previous) }
-    it { Vedeu.must_respond_to(:focussed?) }
-    it { Vedeu.must_respond_to(:geometry) }
-    it { Vedeu.must_respond_to(:goto) }
-    it { Vedeu.must_respond_to(:group) }
-    it { Vedeu.must_respond_to(:height) }
-    it { Vedeu.must_respond_to(:hide_cursor) }
-    it { Vedeu.must_respond_to(:hide_group) }
-    it { Vedeu.must_respond_to(:hide_interface) }
-    it { Vedeu.must_respond_to(:interface) }
-    it { Vedeu.must_respond_to(:keymap) }
-    it { Vedeu.must_respond_to(:keypress) }
-    it { Vedeu.must_respond_to(:log) }
-    it { Vedeu.must_respond_to(:log_stderr) }
-    it { Vedeu.must_respond_to(:log_stdout) }
-    it { Vedeu.must_respond_to(:menu) }
-    it { Vedeu.must_respond_to(:render) }
-    it { Vedeu.must_respond_to(:renders) }
-    it { Vedeu.must_respond_to(:show_cursor) }
-    it { Vedeu.must_respond_to(:show_group) }
-    it { Vedeu.must_respond_to(:show_interface) }
-    it { Vedeu.must_respond_to(:toggle_cursor) }
-    it { Vedeu.must_respond_to(:toggle_group) }
-    it { Vedeu.must_respond_to(:toggle_interface) }
-    it { Vedeu.must_respond_to(:trigger) }
-    it { Vedeu.must_respond_to(:unbind) }
-    it { Vedeu.must_respond_to(:unbind_alias) }
-    it { Vedeu.must_respond_to(:views) }
-    it { Vedeu.must_respond_to(:width) }
-
-  end # API
-
-end # Vedeu

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

@@ -1,148 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  module Buffers
-
-    describe VirtualBuffer do
-
-      let(:described) { Vedeu::Buffers::VirtualBuffer }
-      let(:instance)  { described.new(height, width, renderer) }
-      let(:height)    { 3 }
-      let(:width)     { 3 }
-      let(:renderer)  { Vedeu::Renderers::HTML.new }
-
-      describe '#initialize' do
-        it { instance.must_be_instance_of(described) }
-        it { instance.instance_variable_get('@height').must_equal(3) }
-        it { instance.instance_variable_get('@width').must_equal(3) }
-        it { instance.instance_variable_get('@renderer').must_equal(renderer) }
-      end
-
-      describe 'accessors' do
-        it { instance.must_respond_to(:renderer) }
-        it { instance.must_respond_to(:renderer=) }
-        it { instance.must_respond_to(:height) }
-        it { instance.must_respond_to(:width) }
-      end
-
-      describe '.output' do
-        let(:data) {}
-
-        before do
-          Vedeu.stubs(:width).returns(3)
-          Vedeu.stubs(:height).returns(3)
-        end
-
-        subject { described.output(data) }
-
-        it { subject.must_be_instance_of(Array) }
-      end
-
-      describe '#cells' do
-        before do
-          Vedeu.stubs(:width).returns(3)
-          Vedeu.stubs(:height).returns(3)
-        end
-
-        subject { instance.cells }
-
-        it { subject.must_be_instance_of(Array) }
-        it { subject.size.must_equal(3) }
-        it { subject.flatten.size.must_equal(9) }
-      end
-
-      describe '#read' do
-        subject { instance.read(y, x) }
-
-        context 'when x is out of bounds' do
-          let(:y) { 1 }
-          let(:x) { 5 }
-
-          it { subject.must_equal([]) }
-        end
-
-        context 'when y is out of bounds' do
-          let(:y) { 5 }
-          let(:x) { 1 }
-
-          it { subject.must_equal([]) }
-        end
-
-        context 'when both x and y are out of bounds' do
-          let(:y) { 5 }
-          let(:x) { 5 }
-
-          it { subject.must_equal([]) }
-        end
-
-        context 'when x and y are in bounds' do
-          let(:y) { 0 }
-          let(:x) { 2 }
-
-          it { subject.must_be_instance_of(Vedeu::Models::Cell) }
-        end
-      end
-
-      describe '#output' do
-        it { instance.must_respond_to(:output) }
-      end
-
-      describe '#render' do
-        before do
-          Vedeu.stubs(:width).returns(3)
-          Vedeu.stubs(:height).returns(3)
-        end
-
-        subject { instance.render }
-
-        it { subject.must_be_instance_of(String) }
-      end
-
-      describe '#reset' do
-        subject { instance.reset }
-
-        it { subject.must_be_instance_of(Array) }
-
-        it { instance.must_respond_to(:clear) }
-      end
-
-      describe '#write' do
-        let(:data) { Vedeu::Views::Char.new(value: 'a') }
-
-        subject { instance.write(y, x, data) }
-
-        context 'when x is out of bounds' do
-          let(:y) { 1 }
-          let(:x) { 5 }
-
-          it { subject.must_equal(false) }
-        end
-
-        context 'when y is out of bounds' do
-          let(:y) { 5 }
-          let(:x) { 1 }
-
-          it { subject.must_equal(false) }
-        end
-
-        context 'when both x and y are out of bounds' do
-          let(:y) { 5 }
-          let(:x) { 5 }
-
-          it { subject.must_equal(false) }
-        end
-
-        context 'when x and y are in bounds' do
-          let(:y) { 0 }
-          let(:x) { 2 }
-
-          it { subject.must_equal(true) }
-        end
-      end
-
-    end # VirtualBuffer
-
-  end # Buffers
-
-end # Vedeu

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

@@ -1,73 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  module Buffers
-
-    describe VirtualBuffers do
-
-      let(:described) { Vedeu::Buffers::VirtualBuffers }
-
-      before { described.clear }
-
-      describe '#retrieve' do
-        subject { described.retrieve }
-
-        context 'when no buffers are stored' do
-          it { subject.must_be_instance_of(NilClass) }
-        end
-
-        context 'when buffers are stored' do
-          let(:buffer) { [[Vedeu::Views::Char.new]] }
-
-          before { described.store(buffer) }
-
-          it { subject.must_be_instance_of(Array) }
-
-          it { subject.must_equal(buffer) }
-
-          it 'removes the stored buffer from the storage' do
-            described.size.must_equal(1)
-            subject
-            described.size.must_equal(0)
-          end
-        end
-      end
-
-      describe '#store' do
-        let(:data) { :data }
-
-        subject { described.store(data) }
-
-        it { subject.must_be_instance_of(Array) }
-
-        it { subject.must_equal([:data]) }
-
-        it 'adds the buffer (data) to the storage' do
-          described.size.must_equal(0)
-          subject
-          described.size.must_equal(1)
-        end
-      end
-
-      describe '#size' do
-        subject { described.size }
-
-        it { subject.must_be_instance_of(Fixnum) }
-      end
-
-      describe '#clear' do
-        subject { described.clear }
-
-        it { subject.must_be_instance_of(Array) }
-
-        it { subject.must_be_empty }
-
-        it { described.must_respond_to(:reset) }
-      end
-
-    end # VirtualBuffers
-
-  end # Buffers
-
-end # Vedeu

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

@@ -1,108 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  module Terminal
-
-    describe Content do
-
-      let(:described) { Vedeu::Terminal::Content }
-
-      describe '.valid?' do
-        let(:char) { mock }
-
-        subject { described.valid?(char) }
-
-        context 'when the char does not respond to :position' do
-          it { subject.must_equal(false) }
-        end
-
-        context 'when the char responds to :position' do
-          let(:position) { mock }
-
-          before do
-            char.stubs(:position).returns(position)
-            position.stubs(:x).returns(x)
-            position.stubs(:y).returns(y)
-          end
-
-          context 'but the y value is not present' do
-            let(:x) { 2 }
-            let(:y) {}
-
-            it { subject.must_equal(false) }
-          end
-
-          context 'but the x value is not present' do
-            let(:x) {}
-            let(:y) { 5 }
-
-            it { subject.must_equal(false) }
-          end
-
-          context 'and both y and x values are present' do
-            let(:x) { 2 }
-            let(:y) { 5 }
-
-            it { subject.must_equal(true) }
-          end
-        end
-      end
-
-      describe '#store' do
-        let(:char) {}
-
-        subject { described.store(char) }
-
-        it { subject.must_equal(char) }
-      end
-
-      describe '#stores' do
-        let(:chars) {}
-
-        subject { described.stores(chars) }
-
-        it { subject.must_equal([]) }
-      end
-
-      describe '#write' do
-        subject { described.write }
-
-        context 'when logging is enabled' do
-          # before { Vedeu::Configuration.stubs(:log?).returns(true) }
-          # before { File.stubs(:write) }
-
-          # it {
-          #   File.expects(:write)
-          #   subject
-          # }
-        end
-
-        context 'when logging is not enabled' do
-          before { Vedeu::Configuration.stubs(:log?).returns(false) }
-
-          it { subject.must_equal(nil) }
-        end
-      end
-
-      describe '#reprocess' do
-        before { Vedeu::Terminal.stubs(:clear) }
-
-        subject { described.reprocess }
-
-        it { subject.must_equal(['']) }
-      end
-
-      describe '#reset' do
-        subject { described.reset }
-
-        it { subject.must_be_instance_of(Hash) }
-
-        it { subject.must_be_empty }
-      end
-
-    end # Content
-
-  end # Terminal
-
-end # Vedeu