uh-layout 0.1.1

data/spec/uh/layout/container_spec.rb

@@ -0,0 +1,170 @@
+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 'does not change current entry' do
+            expect { container.current = :baz }
+              .not_to change { container.current }
+          end
+        end
+      end
+
+      describe '#<<' do
+        it 'adds given entry' do
+          container << :baz
+          expect(container).to include :baz
+        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) { [:foo] }
+
+          it 'has no more current entry' do
+            container.remove :foo
+            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.to_a).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.to_a).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
+      end
+
+      describe '#swap' do
+        it 'swaps entries matched by given indexes' do
+          container.swap 0, 1
+          expect(container.to_a).to eq %i[bar foo]
+        end
+      end
+    end
+  end
+end

data/spec/uh/layout/screen_spec.rb

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,62 @@
+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(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 eq tag.columns.current
+          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
+    end
+  end
+end

data/spec/uh/layout_spec.rb

@@ -0,0 +1,414 @@
+module Uh
+  describe Layout do
+    let(:geo)           { build_geo }
+    let(:client)        { build_client }
+    let(:other_client)  { build_client }
+    let(:widget)        { double('widget').as_null_object }
+    subject(:layout)    { described_class.new }
+
+    before do
+      layout.screens << Layout::Screen.new(0, geo)
+      layout.screens << Layout::Screen.new(1, geo)
+      layout.widgets << widget
+    end
+
+    describe '#include?' do
+      it 'returns false when layout does not include given client' do
+        expect(layout.include? client).to be false
+      end
+
+      it 'returns true when layout includes given client' do
+        layout << client
+        expect(layout.include? client).to be true
+      end
+    end
+
+    describe '#arranger_for_current_tag' do
+      it 'returns an arranger for current tag columns and geo' do
+        expect(layout.arranger_for_current_tag)
+          .to respond_to(:update_geos)
+          .and have_attributes(
+            columns:  layout.current_tag.columns,
+            geo:      layout.current_tag.geo
+          )
+      end
+    end
+
+    describe '#update_widgets' do
+      it 'updates widgets' do
+        expect(layout.widgets).to all receive :update
+        layout.update_widgets
+      end
+
+      it 'redraws widgets' do
+        expect(layout.widgets).to all receive :redraw
+        layout.update_widgets
+      end
+    end
+
+    describe '#suggest_geo' do
+      it 'returns current tag geo copy' do
+        expect(layout.suggest_geo)
+          .to eq(layout.current_tag.geo)
+          .and not_be layout.current_tag.geo
+      end
+
+      context 'when current tag has a column' do
+        before { layout.current_tag.columns << Layout::Column.new(build_geo 42) }
+
+        it 'returns current column geo' do
+          expect(layout.suggest_geo)
+            .to eq(layout.current_column.geo)
+            .and not_be layout.current_column.geo
+        end
+      end
+    end
+
+    describe '#<<' do
+      before { layout << other_client }
+
+      it 'adds given client to current column' do
+        layout << client
+        expect(layout.current_column).to include client
+      end
+
+      it 'sets given client as the current one in current column' do
+        layout << client
+        expect(layout.current_column.current_client).to be client
+      end
+
+      it 'arranges current column clients' do
+        expect(layout.current_column).to receive :arrange_clients
+        layout << client
+      end
+
+      it 'shows and hides clients in current column' do
+        expect(layout.current_column).to receive :show_hide_clients
+        layout << client
+      end
+
+      it 'focuses given client' do
+        expect(client).to receive :focus
+        layout << client
+      end
+
+      it 'updates widgets' do
+        expect(widget).to receive :update
+        layout << client
+      end
+
+      it 'returns self' do
+        expect(layout << client).to be layout
+      end
+    end
+
+    describe '#remove' do
+      before { layout << client << other_client }
+
+      it 'removes given client from the layout' do
+        layout.remove client
+        expect(layout).not_to include client
+      end
+
+      it 'redraws columns with an arranger' do
+        expect_any_instance_of(Layout::Column::Arranger).to receive :redraw
+        layout.remove client
+      end
+
+      it 'arranges clients in removed client tag columns' do
+        expect(layout.current_tag.columns).to all receive :arrange_clients
+        layout.remove client
+      end
+
+      it 'shows and hides clients in removed client column' do
+        expect(layout.current_column).to receive :show_hide_clients
+        layout.remove client
+      end
+
+      it 'focuses the new current client' do
+        expect(other_client).to receive :focus
+        layout.remove client
+      end
+
+      it 'updates widgets' do
+        expect(widget).to receive :update
+        layout.remove client
+      end
+    end
+
+    describe 'handle_screen_sel' do
+      it 'selects consecutive screen in given direction' do
+        expect { layout.handle_screen_sel :succ }
+          .to change { layout.current_screen.id }.from(0).to(1)
+      end
+
+      it 'focus selected screen current client' do
+        layout << client
+        expect(client).to receive :focus
+        2.times { layout.handle_screen_sel :succ }
+      end
+
+      it 'updates widgets' do
+        expect(widget).to receive :update
+        layout.handle_screen_sel :succ
+      end
+    end
+
+    describe 'handle_screen_set' do
+      before { layout << client }
+
+      it 'removes current client from origin screen' do
+        layout.handle_screen_set :succ
+        expect(layout.screens[0].tags.flat_map(&:clients)).not_to include client
+      end
+
+      it 'adds current client to consecutive screen in given direction' do
+        layout.handle_screen_set :succ
+        expect(layout.screens[1].tags.flat_map(&:clients)).to include client
+      end
+
+      it 'selects consecutive screen in given direction' do
+        expect { layout.handle_screen_set :succ }
+          .to change { layout.current_screen.id }.from(0).to(1)
+      end
+
+      context 'without client' do
+        before { layout.remove client }
+
+        it 'does not raise any error' do
+          expect { layout.handle_screen_set :succ }.not_to raise_error
+        end
+      end
+    end
+
+    describe 'handle_tag_sel' do
+      before { layout << client }
+
+      it 'hides clients on previously selected tag' do
+        layout.handle_tag_sel '2'
+        expect(client).to be_hidden
+      end
+
+      it 'sets the selected tag as the current one' do
+        layout.handle_tag_sel '2'
+        expect(layout.current_tag.id).to eq '2'
+      end
+
+      it 'shows and hides clients in selected tag columns' do
+        layout.handle_tag_sel '2'
+        expect(layout.current_screen.tags[0].columns)
+          .to all receive :show_hide_clients
+        layout.handle_tag_sel '1'
+      end
+
+      it 'focuses selected tag current client' do
+        layout.handle_tag_sel '2'
+        expect(client).to receive :focus
+        layout.handle_tag_sel '1'
+      end
+
+      it 'updates widgets' do
+        expect(widget).to receive :update
+        layout.handle_tag_sel '2'
+      end
+    end
+
+    describe 'handle_tag_set' do
+      context 'without client' do
+        it 'does not raise any error' do
+          expect { layout.handle_tag_set '2' }.not_to raise_error
+        end
+      end
+
+      context 'with a client' do
+        before { layout << other_client << client }
+
+        it 'removes current client from origin tag' do
+          origin_tag = layout.current_tag
+          layout.handle_tag_set '2'
+          expect(origin_tag).not_to include client
+        end
+
+        it 'shows and hides clients in current column' do
+          expect(layout.current_column).to receive :show_hide_clients
+          layout.handle_tag_set '2'
+        end
+
+        it 'hides current client' do
+          expect(client).to receive :hide
+          layout.handle_tag_set '2'
+        end
+
+        it 'adds current client to given tag' do
+          layout.handle_tag_set '2'
+          dest_tag = layout.current_screen.tags.find { |e| e.id == '2' }
+          expect(dest_tag).to include client
+        end
+
+        it 'arranges clients in given tag columns' do
+          layout.current_screen.tags << tag = Layout::Tag.new('2', geo)
+          expect(tag.current_column_or_create).to receive :arrange_clients
+          layout.handle_tag_set '2'
+        end
+
+        it 'updates widgets' do
+          expect(widget).to receive :update
+          layout.handle_tag_set '2'
+        end
+      end
+    end
+
+    describe '#handle_column_sel' do
+      context 'without client' do
+        it 'does not raise any error' do
+          expect { layout.handle_column_sel :succ }.not_to raise_error
+        end
+      end
+
+      context 'with two clients in two columns' do
+        before do
+          layout << client
+          layout.current_tag.columns << Layout::Column.new(geo).tap do |o|
+            o << other_client
+          end
+        end
+
+        it 'selects the column consecutive to current one in given direction' do
+          layout.handle_column_sel :succ
+          expect(layout.current_column).to be layout.current_tag.columns[1]
+        end
+
+        it 'focuses the current client of selected column' do
+          expect(other_client).to receive :focus
+          layout.handle_column_sel :succ
+        end
+
+        it 'updates widgets' do
+          expect(widget).to receive :update
+          layout.handle_column_sel :succ
+        end
+      end
+    end
+
+    describe '#handle_client_sel' do
+      context 'without client' do
+        it 'does not raise any error' do
+          expect { layout.handle_client_sel :succ }.not_to raise_error
+        end
+      end
+
+      context 'with one column and two clients' do
+        before { layout << client << other_client }
+
+        it 'selects current column consecutive client in given direction' do
+          expect { layout.handle_client_sel :pred }
+            .to change { layout.current_client }.from(other_client).to(client)
+        end
+
+        it 'focuses current client' do
+          expect(client).to receive :focus
+          layout.handle_client_sel :pred
+        end
+
+        it 'updates column clients visibility' do
+          expect(layout.current_column).to receive :show_hide_clients
+          layout.handle_client_sel :pred
+        end
+
+        it 'updates widgets' do
+          expect(widget).to receive :update
+          layout.handle_client_sel :pred
+        end
+      end
+    end
+
+    describe '#handle_client_swap' do
+      context 'without client' do
+        it 'does not raise any error' do
+          expect { layout.handle_client_swap :pred }.not_to raise_error
+        end
+      end
+
+      context 'with one column and two clients' do
+        before { layout << other_client << client }
+
+        it 'swaps current client with the other client' do
+          layout.handle_client_swap :pred
+          expect(layout.current_column.clients.to_a)
+            .to eq [client, other_client]
+        end
+
+        it 'does not change current client' do
+          expect { layout.handle_client_swap :pred }
+            .not_to change { layout.current_client }
+        end
+
+        it 'updates widgets' do
+          expect(widget).to receive :update
+          layout.handle_client_swap :pred
+        end
+      end
+    end
+
+    describe '#handle_client_column_set' do
+      context 'without client' do
+        it 'does not raise any error' do
+          expect { layout.handle_client_column_set :succ }.not_to raise_error
+        end
+      end
+
+      context 'with one column and two clients' do
+        let(:arranger) { instance_spy Layout::Column::Arranger }
+
+        before { layout << other_client << client }
+
+        it 'moves current client with column arranger' do
+          expect(arranger).to receive(:move_current_client).with(:succ)
+          layout.handle_client_column_set :succ, arranger: arranger
+        end
+
+        it 'updates columns geos with column arranger' do
+          expect(arranger).to receive :update_geos
+          layout.handle_client_column_set :succ, arranger: arranger
+        end
+
+        it 'arranges clients in current tag columns' do
+          expect(layout.current_tag.columns).to all receive :arrange_clients
+          layout.handle_client_column_set :succ
+        end
+
+        it 'shows and hides clients in selected tag columns' do
+          expect(layout.current_tag.columns).to all receive :show_hide_clients
+          layout.handle_client_column_set :succ
+        end
+
+        it 'does not change current client' do
+          expect { layout.handle_client_column_set :succ }
+            .not_to change { layout.current_client }
+        end
+
+        it 'updates widgets' do
+          expect(widget).to receive :update
+          layout.handle_client_column_set :succ
+        end
+      end
+    end
+
+    describe '#handle_kill_current' do
+      context 'without client' do
+        it 'does not raise any error' do
+          expect { layout.handle_kill_current }.not_to raise_error
+        end
+      end
+
+      context 'with a client' do
+        before { layout << client }
+
+        it 'kills current client' do
+          expect(client).to receive :kill
+          layout.handle_kill_current
+        end
+      end
+    end
+  end
+end