uh-layout 0.3.0 → 0.3.1

data/spec/uh/layout/container_spec.rb

@@ -1,194 +0,0 @@
-module Uh
-  class Layout
-    describe Container do
-      let(:entries)       { %i[foo bar] }
-      subject(:container) { described_class.new entries }
-
-      describe '#initialize' do
-        it 'assigns no entries when no arguments are given' do
-          expect(described_class.new).to be_empty
-        end
-      end
-
-      describe '#to_ary' do
-        it 'supports implicit conversion to array' do
-          expect([] + container).to eq %i[foo bar]
-        end
-      end
-
-      describe '#current' do
-        context 'when container has multiple entries' do
-          it 'returns the first entry' do
-            expect(container.current).to be :foo
-          end
-        end
-
-        context 'when container has no entry' do
-          subject(:container) { described_class.new }
-
-          it 'returns nil' do
-            expect(container.current).to be nil
-          end
-        end
-      end
-
-      describe '#current=' do
-        context 'when given argument is an entry' do
-          before { container.current = :bar }
-
-          it 'assigns given entry as the current one' do
-            expect(container.current).to be :bar
-          end
-        end
-
-        context 'when given argument is not an entry' do
-          it 'raises ArgumentError' do
-            expect { container.current = :unknown_entry }
-              .to raise_error Layout::ArgumentError
-          end
-        end
-      end
-
-      describe '#<<' do
-        it 'adds given entry' do
-          container << :baz
-          expect(container).to include :baz
-        end
-      end
-
-      describe '#insert_after_current' do
-        it 'inserts given entry after current one' do
-          container.insert_after_current :baz
-          expect(container.entries).to eq %i[foo baz bar]
-        end
-
-        context 'when container has no entry' do
-          let(:entries) { [] }
-
-          it 'raises a RuntimeError' do
-            expect { container.insert_after_current :foo }
-              .to raise_error Layout::RuntimeError
-          end
-        end
-      end
-
-      describe '#remove' do
-        let(:entries) { %i[foo bar baz] }
-
-        before { container.current = :bar }
-
-        it 'removes given argument from entries' do
-          container.remove :foo
-          expect(container).not_to include :foo
-        end
-
-        it 'preserves the current entry' do
-          container.remove :foo
-          expect(container.current).to be :bar
-        end
-
-        it 'returns self' do
-          expect(container.remove :foo).to be container
-        end
-
-        it 'raises an ArgumentError when given entry is not included' do
-          expect { container.remove :unknown_entry }.to raise_error ArgumentError
-        end
-
-        context 'when the first and current entry is removed' do
-          before do
-            container.current = :foo
-            container.remove :foo
-          end
-
-          it 'assigns next entry as the current one' do
-            expect(container.current).to be :bar
-          end
-        end
-
-        context 'when given entry is the only one' do
-          let(:entries) { [:bar] }
-
-          it 'has no more current entry' do
-            container.remove :bar
-            expect(container.current).to be nil
-          end
-        end
-      end
-
-      describe '#remove_if' do
-        it 'removes entries for which given block returns true' do
-          container.remove_if { |e| e == :foo }
-          expect(container).not_to include :foo
-        end
-      end
-
-      describe '#get' do
-        it 'returns consecutive entry in given direction' do
-          expect(container.get :succ).to be :bar
-        end
-
-        it 'returns nil when no consecutive entry exists' do
-          expect(container.get :pred).to be nil
-        end
-
-        context 'with cycle option' do
-          it 'returns consecutive entry, cycling before first one' do
-            expect(container.get :pred, cycle: true).to be :bar
-          end
-
-          it 'returns consecutive entry, cycling after last one' do
-            container.current = :bar
-            expect(container.get :succ, cycle: true).to be :foo
-          end
-        end
-      end
-
-      describe '#sel' do
-        it 'sets consecutive entry in given direction as the current one' do
-          container.sel :next
-          expect(container.current).to be :bar
-        end
-      end
-
-      describe '#set' do
-        let(:entries) { %i[foo bar baz] }
-
-        it 'swaps current entry with consecutive one in given direction' do
-          container.set :next
-          expect(container.entries).to eq %i[bar foo baz]
-        end
-
-        it 'does not change current entry' do
-          expect { container.set :next }.not_to change { container.current }
-        end
-
-        context 'when direction is out of range' do
-          it 'rotates the entries' do
-            container.set :pred
-            expect(container.entries).to eq %i[bar baz foo]
-          end
-
-          it 'does not change current entry' do
-            expect { container.set :pred }.not_to change { container.current }
-          end
-        end
-
-        context 'when entries count is less than 2' do
-          let(:entries) { %i[foo] }
-
-          it 'raises a RuntimeError' do
-            expect { container.set :pred }.to raise_error Layout::RuntimeError
-          end
-        end
-      end
-
-      describe '#swap' do
-        it 'swaps entries matched by given indexes' do
-          container.swap 0, 1
-          expect(container.entries).to eq %i[bar foo]
-        end
-      end
-    end
-  end
-end

data/spec/uh/layout/history_spec.rb

@@ -1,32 +0,0 @@
-module Uh
-  class Layout
-    describe History do
-      subject(:history) { described_class.new }
-
-      it 'has an empty tag history' do
-        expect(history.tags).to be_empty
-      end
-
-      describe '#record_tag' do
-        it 'adds current tag' do
-          history.record_tag :some_tag
-          expect(history.tags).to include :some_tag
-        end
-
-        it 'limits stored tags count to configured tags size' do
-          history.tags_size_max.times { |n| history.record_tag "tag_#{n}" }
-          expect { history.record_tag :one_more }
-            .not_to change { history.tags.size }
-        end
-      end
-
-      describe '#last_tag' do
-        it 'returns last recorded tag' do
-          history.record_tag :tag_1
-          history.record_tag :tag_2
-          expect(history.last_tag).to be :tag_2
-        end
-      end
-    end
-  end
-end

data/spec/uh/layout/registrant_spec.rb

@@ -1,46 +0,0 @@
-module Uh
-  class Layout
-    describe Registrant do
-      let(:layout)  { Layout.new }
-      let(:geo)     { build_geo }
-      let(:screen)  { double 'screen', id: 0, geo: geo, height: geo.height }
-      let(:display) { double 'display', screens: [screen] }
-      let(:bar)     { instance_spy Bar, height: 16 }
-
-      before do
-        allow(Bar).to receive(:new) { bar }
-      end
-
-      describe '#register' do
-        it 'registers display screens as layout screens' do
-          described_class.register layout, display
-          expect(layout.screens[0])
-            .to be_a(Screen)
-            .and have_attributes(id: 0)
-        end
-
-        it 'builds a new bar widget' do
-          expect(Bar)
-            .to receive(:new)
-            .with display, an_instance_of(Screen), layout.colors
-          described_class.register layout, display
-        end
-
-        it 'registers the bar widget' do
-          described_class.register layout, display
-          expect(layout.widgets[0]).to be bar
-        end
-
-        it 'decreases the layout screens height with the bar height' do
-          described_class.register layout, display
-          expect(layout.screens[0].height).to eq screen.height - bar.height
-        end
-
-        it 'updates layout widgets' do
-          expect(layout).to receive :update_widgets
-          described_class.register layout, display
-        end
-      end
-    end
-  end
-end

data/spec/uh/layout/screen_spec.rb

@@ -1,40 +0,0 @@
-module Uh
-  class Layout
-    describe Screen do
-      let(:geo)         { build_geo }
-      let(:other_geo)   { build_geo 640, 0, 320, 240 }
-      let(:client)      { build_client }
-      subject(:screen)  { described_class.new 0, geo }
-
-      it 'has one default tag with id 1 assigned' do
-        expect(screen.tags).to include an_object_having_attributes id: '1'
-      end
-
-      it 'has one default tag with screen geo copy assigned' do
-        expect(screen.tags.first.geo).to eq(screen.geo).and not_be screen.geo
-      end
-
-      describe '#height=' do
-        it 'changes screen height' do
-          expect { screen.height = 42 }.to change { screen.height }.to 42
-        end
-
-        it 'changes tags height' do
-          expect { screen.height = 42 }
-            .to change { screen.tags.first.height }.to 42
-        end
-      end
-
-      describe '#include?' do
-        it 'returns false when screen does not include given client' do
-          expect(screen.include? client).to be false
-        end
-
-        it 'returns true when screen includes given client' do
-          screen.current_tag.current_column_or_create << client
-          expect(screen.include? client).to be true
-        end
-      end
-    end
-  end
-end

data/spec/uh/layout/tag_spec.rb

@@ -1,91 +0,0 @@
-module Uh
-  class Layout
-    describe Tag do
-      let(:geo)           { build_geo }
-      let(:other_geo)     { build_geo 640, 0, 320, 240 }
-      let(:client)        { build_client }
-      let(:other_client)  { build_client }
-      let(:column)        { Column.new(geo) }
-      subject(:tag)       { described_class.new '1', geo }
-
-      describe '.new' do
-        it 'raises error unless id converts to string' do
-          expect { described_class.new 1, geo }
-            .to raise_error(Layout::ArgumentError)
-        end
-      end
-
-      describe '#clients' do
-        it 'returns all clients contained in assigned columns' do
-          tag.columns << column.tap { |column| column << client << other_client }
-          expect(tag.clients).to eq [client, other_client]
-        end
-      end
-
-      describe '#include?' do
-        it 'returns false when tag does not include given client' do
-          expect(tag.include? client).to be false
-        end
-
-        it 'returns true when tag includes given client' do
-          tag.columns << column.tap { |column| column << client }
-          expect(tag.include? client).to be true
-        end
-      end
-
-      describe '#current_column_or_create' do
-        context 'when tag has no column' do
-          it 'creates a new column' do
-            expect { tag.current_column_or_create }
-              .to change { tag.columns.size }.from(0).to(1)
-          end
-
-          it 'returns the new column' do
-            expect(tag.current_column_or_create).to be tag.columns.fetch 0
-          end
-        end
-
-        context 'when tag has a column' do
-          before { tag.columns << column }
-
-          it 'does not create any column' do
-            expect { tag.current_column_or_create }
-              .not_to change { tag.columns.size }
-          end
-
-          it 'returns the current column' do
-            expect(tag.current_column_or_create).to be column
-          end
-        end
-      end
-
-      describe '#arranger' do
-        it 'returns a fixed width arranger' do
-          expect(tag.arranger).to be_an Arrangers::FixedWidth
-        end
-      end
-
-      describe '#arrange_columns' do
-        before { tag.columns << column }
-
-        it 'purges empty columns' do
-          tag.arrange_columns
-          expect(tag.columns).to be_empty
-        end
-
-        it 'arranges columns' do
-          arranger = instance_spy Arrangers::FixedWidth
-          allow(tag).to receive(:arranger) { arranger }
-          expect(arranger).to receive :arrange
-          tag.arrange_columns
-        end
-
-        it 'arranges columns clients' do
-          column << client
-          expect(column).to receive :arrange_clients
-          tag.arrange_columns
-        end
-      end
-    end
-  end
-end