uh-layout 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13e0b24b7af337b1124358fdd2719f9489d753c4
-  data.tar.gz: c1cc1e138a983f9b32e5237123665ebe57382dfd
+  metadata.gz: 47a100f2229b06ab1aa01eeb35e1b8baba73f804
+  data.tar.gz: 3cc639552ca1d7cfa766a0d6afb03dab85532b86
 SHA512:
-  metadata.gz: 332e7d81affd715faf55fd6f0b424da82b7b0852907052a228c8017458c5a25ae8488ff1c2b3afa0c5c62abfef11ab72c6538557542204132b3c88d515d4dfe2
-  data.tar.gz: 327f4d842b1e3cd74cfb818991ee0c71ee1777d5767752d6415a1d59a90f041fa0e59af7241fb3df196a2ad166c6232d44e9117c74c0ee3efdbe5377090ea10c
+  metadata.gz: 2c0c3f914c932e129fb9eaf10c18a6fe7cc90335adec8f4822aecda6a6856204ceff06e832016d59716de7b08506450f49b0c56c36b53198d6e29bce3a31f621
+  data.tar.gz: 8a7ce44e77e6edad1746dc478253a0a742c404538e0b9d771e605ad67a6ecc6c19843a1f984cdec1ed4841d697a467574134aa6568d7105edcbe726f7943328c

data/.gitignore

@@ -1,2 +1,3 @@
+/Gemfile-custom.rb
 /Gemfile.lock
 /tmp/

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - ruby-head
+  - rbx-2

data/lib/uh/layout/arrangers/fixed_width.rb

@@ -0,0 +1,30 @@
+module Uh
+  class Layout
+    module Arrangers
+      class FixedWidth
+        DEFAULT_WIDTH = 484
+
+        def initialize(entries, geo, width: DEFAULT_WIDTH)
+          @entries  = entries
+          @geo      = geo
+          @width    = width
+        end
+
+        def arrange
+          return if @entries.empty?
+          @entries.each_with_index do |column, i|
+            column.x      = @width * i + @geo.x
+            column.y      = @geo.y
+            column.width  = @width
+            column.height = @geo.height
+          end
+          @entries.last.width = @geo.width - (@entries.last.x - @geo.x)
+        end
+
+        def max_count?
+          (@geo.width / (@entries.size + 1)) < @width
+        end
+      end
+    end
+  end
+end

data/lib/uh/layout/arrangers/stack.rb

@@ -0,0 +1,24 @@
+module Uh
+  class Layout
+    module Arrangers
+      class Stack
+        def initialize(entries, geo)
+          @entries  = entries
+          @geo      = geo
+        end
+
+        def arrange
+          @entries.each { |e| e.geo = @geo.dup }
+        end
+
+        def each_visible
+          yield @entries.current if @entries.current
+        end
+
+        def each_hidden
+          ([*@entries] - [@entries.current]).each { |e| yield e }
+        end
+      end
+    end
+  end
+end

data/lib/uh/layout/arrangers/vert_tile.rb

@@ -0,0 +1,28 @@
+module Uh
+  class Layout
+    module Arrangers
+      class VertTile
+        def initialize(entries, geo)
+          @entries  = entries
+          @geo      = geo
+        end
+
+        def arrange
+          entry_height = @geo.height / @entries.size - 1
+          @entries.each_with_index do |entry, i|
+            entry.geo     = @geo.dup
+            entry.y       = (entry_height + 1) * i
+            entry.height  = entry_height
+          end
+        end
+
+        def each_visible
+          @entries.each { |e| yield e }
+        end
+
+        def each_hidden
+        end
+      end
+    end
+  end
+end

data/lib/uh/layout/client_column_mover.rb

@@ -0,0 +1,33 @@
+module Uh
+  class Layout
+    class ClientColumnMover
+      def initialize(columns, columns_max_count)
+        @columns            = columns
+        @columns_max_count  = columns_max_count
+      end
+
+      def move_current(direction)
+        @columns.current.remove client = @columns.current.current_client
+        dest_column = get_or_create_column direction
+        dest_column << client
+        dest_column.current_client = client
+        @columns.current = dest_column
+      end
+
+      def get_or_create_column(direction)
+        if candidate = @columns.get(direction)
+          candidate
+        elsif @columns_max_count
+          @columns.get direction, cycle: true
+        else
+          Column.new(Geo.new).tap do |o|
+            case direction
+            when :pred then @columns.unshift o
+            when :succ then @columns << o
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/uh/layout/column.rb

@@ -1,6 +1,11 @@
 module Uh
   class Layout
     class Column
+      MODES = {
+        stack:  Arrangers::Stack,
+        tile:   Arrangers::VertTile
+      }.freeze
+
       include GeoAccessors
 
       extend Forwardable
@@ -9,11 +14,12 @@ module Uh
       def_delegator :@clients, :current=, :current_client=
       def_delegator :current_client, :==, :current_client?
 
-      attr_reader :geo, :clients
+      attr_reader :geo, :clients, :mode
 
       def initialize(geo)
         @geo      = geo.dup
         @clients  = Container.new
+        @mode     = :stack
       end
 
       def to_s
@@ -26,18 +32,22 @@ module Uh
         self
       end
 
+      def mode_toggle
+        @mode = MODES.keys[(MODES.keys.index(@mode) + 1) % MODES.keys.size]
+      end
+
+      def arranger
+        MODES[@mode].new @clients, @geo
+      end
+
       def arrange_clients
-        @clients.each do |client|
-          client.geo = @geo.dup
-          client.moveresize
-        end
+        arranger.arrange
+        clients.each &:moveresize
       end
 
-      def show_hide_clients
-        @clients.each do |client|
-          client.hide unless client.hidden? || @clients.current == client
-        end
-        @clients.current.show if @clients.current && @clients.current.hidden?
+      def show_hide_clients(arranger: self.arranger)
+        arranger.each_visible { |client| client.show if client.hidden? }
+        arranger.each_hidden  { |client| client.hide unless client.hidden? }
       end
     end
   end

data/lib/uh/layout/container.rb

@@ -4,8 +4,8 @@ module Uh
       include Enumerable
 
       extend Forwardable
-      def_delegators :@entries, :<<, :[], :each, :empty?, :first, :index, :last,
-        :size, :unshift
+      def_delegators :@entries, :<<, :[], :each, :empty?, :fetch, :first,
+        :index, :last, :size, :unshift
 
       def initialize(entries = [])
         @entries        = entries
@@ -19,7 +19,8 @@ module Uh
       end
 
       def current=(entry)
-        @current_index = @entries.index entry if include? entry
+        fail ArgumentError, 'unknown entry' unless include? entry
+        @current_index = @entries.index entry
       end
 
       def remove(entry)

data/lib/uh/layout/tag.rb

@@ -9,6 +9,7 @@ module Uh
       def_delegator :@columns, :each, :each_column
       def_delegator :current_column, :==, :current_column?
       def_delegator :clients, :each, :each_client
+      def_delegator :arranger, :max_count?, :columns_max_count?
 
       attr_reader :id, :geo, :columns
 
@@ -39,6 +40,16 @@ module Uh
         end
       end
 
+      def arranger
+        Arrangers::FixedWidth.new(@columns, @geo)
+      end
+
+      def arrange_columns
+        @columns.remove_if &:empty?
+        arranger.arrange
+        @columns.each &:arrange_clients
+      end
+
       def hide
         clients.each &:hide
       end

data/lib/uh/layout/version.rb

@@ -1,5 +1,5 @@
 module Uh
   class Layout
-    VERSION = '0.1.2'
+    VERSION = '0.1.3'
   end
 end

data/lib/uh/layout.rb

@@ -1,16 +1,21 @@
 require 'forwardable'
 
-require 'uh/layout/geo_accessors'
+require 'uh/layout/arrangers/fixed_width'
+require 'uh/layout/arrangers/stack'
+require 'uh/layout/arrangers/vert_tile'
 require 'uh/layout/bar'
+require 'uh/layout/client_column_mover'
 require 'uh/layout/container'
 require 'uh/layout/column'
-require 'uh/layout/column/arranger'
 require 'uh/layout/dumper'
 require 'uh/layout/screen'
 require 'uh/layout/tag'
 
 module Uh
   class Layout
+    Error         = Class.new(StandardError)
+    ArgumentError = Class.new(Error)
+
     extend Forwardable
     def_delegator :@screens, :current, :current_screen
     def_delegator :current_screen, :==, :current_screen?
@@ -36,10 +41,6 @@ module Uh
       screens.any? { |screen| screen.include? client }
     end
 
-    def arranger_for_current_tag
-      Column::Arranger.new(current_tag.columns, current_tag.geo)
-    end
-
     def update_widgets
       @widgets.each &:update
       @widgets.each &:redraw
@@ -63,8 +64,7 @@ module Uh
     def remove(client)
       screen, tag, column = find_client client
       column.remove client
-      Column::Arranger.new(tag.columns, tag.geo).redraw
-      tag.each_column &:arrange_clients
+      tag.arrange_columns
       column.show_hide_clients
       current_client.focus if current_client
       update_widgets
@@ -94,14 +94,11 @@ module Uh
 
     def handle_tag_set(tag_id)
       return unless current_client && current_tag.id != tag_id
+      previous_tag_id = current_tag.id
       remove client = current_client
-      client.hide
-      tag = find_tag_or_create tag_id
-      tag.current_column_or_create << client
-      Column::Arranger.new(tag.columns, tag.geo).redraw
-      tag.each_column &:arrange_clients
-      current_client.focus if current_client
-      update_widgets
+      handle_tag_sel tag_id
+      push client
+      handle_tag_sel previous_tag_id
     end
 
     def handle_column_sel(direction)
@@ -111,6 +108,13 @@ module Uh
       update_widgets
     end
 
+    def handle_column_mode_toggle
+      return unless current_column
+      current_column.mode_toggle
+      current_column.arrange_clients
+      current_column.show_hide_clients
+    end
+
     def handle_client_sel(direction)
       return unless current_client
       current_column.clients.sel direction
@@ -125,10 +129,10 @@ module Uh
       update_widgets
     end
 
-    def handle_client_column_set(direction, arranger: arranger_for_current_tag)
+    def handle_client_column_set(direction, mover: client_mover_for_current_tag)
       return unless current_client
-      arranger.move_current_client(direction).update_geos
-      current_tag.each_column &:arrange_clients
+      mover.move_current direction
+      current_tag.arrange_columns
       current_tag.each_column &:show_hide_clients
       update_widgets
     end
@@ -157,5 +161,9 @@ module Uh
         current_screen.tags << tag
       end
     end
+
+    def client_mover_for_current_tag
+      ClientColumnMover.new(current_tag.columns, current_tag.columns_max_count?)
+    end
   end
 end

data/spec/support/factories.rb

@@ -1,8 +1,22 @@
 module Factories
+  class Entry
+    include Uh::GeoAccessors
+
+    attr_accessor :geo
+
+    def initialize(geo)
+      @geo = geo
+    end
+  end
+
   def build_client
     Uh::WM::Client.new(instance_spy Uh::Window)
   end
 
+  def build_entry(geo = build_geo)
+    Entry.new(geo)
+  end
+
   def build_geo(x = 0, y = 0, width = 640, height = 480)
     Uh::Geo.new(x, y, width, height)
   end

data/spec/uh/layout/arrangers/fixed_width_spec.rb

@@ -0,0 +1,72 @@
+module Uh
+  class Layout
+    module Arrangers
+      describe FixedWidth do
+        let(:geo)           { build_geo 20, 0, 640, 480 }
+        let(:entry)         { build_entry }
+        let(:entries)       { Container.new([entry, build_entry]) }
+        subject(:arranger)  { described_class.new entries, geo, width: 300 }
+
+        describe '#arrange' do
+          it 'decreases first entry width as the optimal width' do
+            arranger.arrange
+            expect(entries[0].width).to eq 300
+          end
+
+          it 'offsets entries with given geo' do
+            arranger.arrange
+            expect(entries[0].x).to eq 20
+          end
+
+          it 'moves second entry aside the first entry' do
+            arranger.arrange
+            expect(entries[1].x).to eq 320
+          end
+
+          it 'increases last entry width to occupy remaining width' do
+            arranger.arrange
+            expect(entries[1].width).to eq 340
+          end
+
+          it 'copies given geo y' do
+            entries[0].y = nil
+            arranger.arrange
+            expect(entries[0].y).to eq 0
+          end
+
+          it 'copies given geo height' do
+            entries[0].height = nil
+            arranger.arrange
+            expect(entries[0].height).to eq 480
+          end
+
+          context 'without entry' do
+            let(:entries) { Container.new([]) }
+
+            it 'does not raise any error' do
+              expect { arranger.arrange }.not_to raise_error
+            end
+          end
+        end
+
+        describe '#max_count?' do
+          context 'when a new entry fits in current geo' do
+            let(:entries) { Container.new([entry]) }
+
+            it 'returns false' do
+              expect(arranger.max_count?).to be false
+            end
+          end
+
+          context 'when current geo can not contain more entry' do
+            let(:entries) { Container.new([entry, entry.dup]) }
+
+            it 'returns true' do
+              expect(arranger.max_count?).to be true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/uh/layout/arrangers/stack_spec.rb

@@ -0,0 +1,42 @@
+module Uh
+  class Layout
+    module Arrangers
+      describe Stack do
+        let(:entry)         { build_entry }
+        let(:other_entry)   { build_entry }
+        let(:entries)       { Container.new([entry, other_entry]) }
+        let(:geo)           { build_geo 0, 0, 300, 480 }
+        subject(:arranger)  { described_class.new entries, geo }
+
+        describe '#arrange' do
+          it 'sets given geo on all entries' do
+            arranger.arrange
+            expect(entries.map(&:geo)).to all eq geo
+          end
+        end
+
+        describe '#each_visible' do
+          it 'yields current entry' do
+            expect { |b| arranger.each_visible &b }
+              .to yield_successive_args entry
+          end
+
+          context 'with no current entry' do
+            let(:entries) { Container.new([]) }
+
+            it 'does not yield' do
+              expect { |b| arranger.each_visible &b }.not_to yield_control
+            end
+          end
+        end
+
+        describe '#each_hidden' do
+          it 'yields all entries except current one' do
+            expect { |b| arranger.each_hidden &b }
+              .to yield_successive_args other_entry
+          end
+        end
+      end
+    end
+  end
+end

data/spec/uh/layout/arrangers/vert_tile_spec.rb

@@ -0,0 +1,49 @@
+module Uh
+  class Layout
+    module Arrangers
+      describe VertTile do
+        let(:entry)         { build_entry }
+        let(:other_entry)   { build_entry }
+        let(:entries)       { Container.new([entry, other_entry]) }
+        let(:geo)           { build_geo 0, 0, 300, 480 }
+        subject(:arranger)  { described_class.new entries, geo }
+
+        describe '#arrange' do
+          it 'sets x offset from given geo on all entries' do
+            arranger.arrange
+            expect(entries.map(&:x)).to all eq 0
+          end
+
+          it 'sets width from given geo on all entries' do
+            arranger.arrange
+            expect(entries.map(&:width)).to all eq 300
+          end
+
+          it 'splits entries height equally' do
+            arranger.arrange
+            expect(entries.map(&:height)).to all eq 239
+          end
+
+          it 'adds a margin between entries' do
+            arranger.arrange
+            expect(entries[1].y - entries[0].height - entries[0].y).to eq 1
+          end
+        end
+
+        describe '#each_visible' do
+          it 'yields all entries' do
+            expect { |b| arranger.each_visible &b }
+              .to yield_successive_args entry, other_entry
+          end
+        end
+
+        describe '#each_hidden' do
+          it 'yields no entry' do
+            expect { |b| arranger.each_hidden &b }.not_to yield_control
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/uh/layout/client_column_mover_spec.rb

@@ -0,0 +1,96 @@
+module Uh
+  class Layout
+    describe ClientColumnMover do
+      let(:client)            { build_client }
+      let(:column)            { Column.new(build_geo) }
+      let(:columns)           { Container.new([column]) }
+      let(:columns_max_count) { false }
+      subject(:mover)         { described_class.new columns, columns_max_count }
+
+      describe '#move_current' do
+        shared_examples 'moves current client' do |expected_column_index|
+          it 'removes current client from origin column' do
+            mover.move_current :succ
+            expect(column).not_to include client
+          end
+
+          it 'adds current client in the destination column' do
+            mover.move_current :succ
+            expect(columns[expected_column_index]).to include client
+          end
+
+          it 'updates destination column as the current one' do
+            mover.move_current :succ
+            expect(columns.current).to be columns[expected_column_index]
+          end
+
+          it 'preserves current client as the current one' do
+            expect { mover.move_current :succ }
+              .not_to change { columns.current.current_client }
+          end
+        end
+
+        context 'given one column with one client' do
+          before { column << client }
+
+          include_examples 'moves current client', 1
+        end
+
+        context 'given one column with many clients' do
+          before { column << client << client.dup }
+
+          include_examples 'moves current client', 1
+        end
+
+        context 'given two columns' do
+          let(:columns) { Container.new([column, Column.new(build_geo)]) }
+
+          before { columns[1] << client.dup }
+
+          context 'when origin column has many clients' do
+            before { column << client << client.dup }
+
+            include_examples 'moves current client', 1
+          end
+
+          context 'when origin column has one client' do
+            before { column << client }
+
+            include_examples 'moves current client', 1
+          end
+        end
+      end
+
+      describe '#get_or_create_column' do
+        let(:columns) { Container.new([column, Column.new(build_geo)]) }
+
+        it 'returns the consecutive column in given direction' do
+          expect(mover.get_or_create_column :succ).to be columns[1]
+        end
+
+        context 'when current column is last in given direction' do
+          before { columns.current = columns[1] }
+
+          context 'when max columns count is not reached' do
+            it 'appends a new column' do
+              expect(mover.get_or_create_column :succ).to be columns[2]
+            end
+
+            it 'prepends a new column' do
+              columns.current = columns[0]
+              expect(mover.get_or_create_column :pred).to be columns[0]
+            end
+          end
+
+          context 'when max columns count is reached' do
+            let(:columns_max_count) { true }
+
+            it 'returns the consecutive column in given direction' do
+              expect(mover.get_or_create_column :succ).to be columns[0]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/uh/layout/column_spec.rb

@@ -5,7 +5,7 @@ module Uh
       let(:other_geo)     { build_geo 640, 0, 320, 240 }
       let(:client)        { build_client }
       let(:other_client)  { build_client }
-      subject(:column)    { described_class.new(geo) }
+      subject(:column)    { described_class.new geo }
 
       it 'has a copy to given geo' do
         expect(column.geo).to eq(geo).and not_be geo
@@ -15,6 +15,10 @@ module Uh
         expect(column).to be_empty
       end
 
+      it 'has :stack as default mode' do
+        expect(column.mode).to be :stack
+      end
+
       describe '#<<' do
         before { column << client }
 
@@ -31,13 +35,43 @@ module Uh
         end
       end
 
+      describe '#mode_toggle' do
+        it 'toggles mode from stack to tile' do
+          expect { column.mode_toggle }
+            .to change { column.mode }.from(:stack).to(:tile)
+        end
+
+        it 'toggles mode from tile to stack' do
+          column.mode_toggle
+          expect { column.mode_toggle }
+            .to change { column.mode }.from(:tile).to(:stack)
+        end
+
+      end
+
+      describe '#arranger' do
+        context 'when column mode is stack' do
+          it 'returns a stack arranger' do
+            expect(column.arranger).to be_an Arrangers::Stack
+          end
+        end
+
+        context 'when column mode is tile' do
+          it 'returns a vertical tile arranger' do
+            column.mode_toggle
+            expect(column.arranger).to be_an Arrangers::VertTile
+          end
+        end
+      end
+
       describe '#arrange_clients' do
         before { column << client << other_client }
 
-        it 'updates clients geometries' do
-          column.width = 320
+        it 'arranges clients' do
+          arranger = instance_spy Arrangers::Stack
+          allow(column).to receive(:arranger) { arranger }
+          expect(arranger).to receive :arrange
           column.arrange_clients
-          expect(column.clients.map(&:geo)).to all eq column.geo
         end
 
         it 'moveresizes clients' do
@@ -47,18 +81,24 @@ module Uh
       end
 
       describe '#show_hide_clients' do
-        before { column << client << other_client }
+        let(:arranger) { double 'arranger', each_visible: nil, each_hidden: nil }
 
-        it 'shows current client only' do
+        it 'shows visible clients when they are hidden' do
+          allow(arranger).to receive(:each_visible)
+            .and_yield(client.hide)
+            .and_yield(other_client.show)
+          expect(client).to receive :show
           expect(other_client).not_to receive :show
-          expect(client.hide).to receive :show
-          column.show_hide_clients
+          column.show_hide_clients arranger: arranger
         end
 
-        it 'hides non-current clients' do
-          expect(client).not_to receive :hide
-          expect(other_client.show).to receive :hide
-          column.show_hide_clients
+        it 'hides hidden clients except those already hidden' do
+          allow(arranger).to receive(:each_hidden)
+            .and_yield(client.show)
+            .and_yield(other_client.hide)
+          expect(client).to receive :hide
+          expect(other_client).not_to receive :hide
+          column.show_hide_clients arranger: arranger
         end
       end
     end

data/spec/uh/layout/container_spec.rb

@@ -42,9 +42,9 @@ module Uh
         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 }
+          it 'raises ArgumentError' do
+            expect { container.current = :unknown_entry }
+              .to raise_error Layout::ArgumentError
           end
         end
       end
@@ -91,10 +91,10 @@ module Uh
         end
 
         context 'when given entry is the only one' do
-          let(:entries) { [:foo] }
+          let(:entries) { [:bar] }
 
           it 'has no more current entry' do
-            container.remove :foo
+            container.remove :bar
             expect(container.current).to be nil
           end
         end

data/spec/uh/layout/screen_spec.rb

@@ -4,7 +4,7 @@ module Uh
       let(:geo)         { build_geo }
       let(:other_geo)   { build_geo 640, 0, 320, 240 }
       let(:client)      { build_client }
-      subject(:screen)  { described_class.new(0, geo) }
+      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'

data/spec/uh/layout/tag_spec.rb

@@ -6,11 +6,12 @@ module Uh
       let(:client)        { build_client }
       let(:other_client)  { build_client }
       let(:column)        { Column.new(geo) }
-      subject(:tag)       { described_class.new('1', 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)
+          expect { described_class.new 1, geo }
+            .to raise_error(Layout::ArgumentError)
         end
       end
 
@@ -40,7 +41,7 @@ module Uh
           end
 
           it 'returns the new column' do
-            expect(tag.current_column_or_create).to eq tag.columns.current
+            expect(tag.current_column_or_create).to be tag.columns.fetch 0
           end
         end
 
@@ -57,6 +58,34 @@ module Uh
           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

data/spec/uh/layout_spec.rb

@@ -23,17 +23,6 @@ module Uh
       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
@@ -110,13 +99,8 @@ module Uh
         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
+      it 'arranges columns in removed client tag' do
+        expect(layout.current_tag).to receive :arrange_columns
         layout.remove client
       end
 
@@ -229,8 +213,8 @@ module Uh
           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
+        it 'removes current client from layout' do
+          expect(layout).to receive(:remove).with client
           layout.handle_tag_set '2'
         end
 
@@ -245,10 +229,9 @@ module Uh
           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
+        it 'preserves current tag' do
           layout.handle_tag_set '2'
+          expect(layout.current_tag.id).to eq '1'
         end
 
         it 'updates widgets' do
@@ -290,6 +273,33 @@ module Uh
       end
     end
 
+    describe '#handle_column_mode_toggle' do
+      context 'without column' do
+        it 'does not raise any error' do
+          expect { layout.handle_column_mode_toggle }.not_to raise_error
+        end
+      end
+
+      context 'with a column' do
+        before { layout << client }
+
+        it 'toggles current column mode' do
+          expect(layout.current_column).to receive :mode_toggle
+          layout.handle_column_mode_toggle
+        end
+
+        it 'arranges current column clients' do
+          expect(layout.current_column).to receive :arrange_clients
+          layout.handle_column_mode_toggle
+        end
+
+        it 'shows and hides clients in current column' do
+          expect(layout.current_column).to receive :show_hide_clients
+          layout.handle_column_mode_toggle
+        end
+      end
+    end
+
     describe '#handle_client_sel' do
       context 'without client' do
         it 'does not raise any error' do
@@ -358,22 +368,17 @@ module Uh
       end
 
       context 'with one column and two clients' do
-        let(:arranger) { instance_spy Layout::Column::Arranger }
+        let(:mover) { instance_spy Layout::ClientColumnMover }
 
         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
+        it 'moves current client with given client column mover' do
+          expect(mover).to receive(:move_current).with(:succ)
+          layout.handle_client_column_set :succ, mover: mover
         end
 
-        it 'arranges clients in current tag columns' do
-          expect(layout.current_tag.columns).to all receive :arrange_clients
+        it 'arranges current tag columns' do
+          expect(layout.current_tag).to receive :arrange_columns
           layout.handle_client_column_set :succ
         end
 

data/uh-layout.gemspec

@@ -15,8 +15,7 @@ Gem::Specification.new do |s|
   s.executables = s.files.grep(/\Abin\//) { |f| File.basename(f) }
 
 
-  s.add_dependency 'uh', '~> 0.1.2'
-
+  s.add_development_dependency 'uh'
   s.add_development_dependency 'rake',  '~> 10.4'
   s.add_development_dependency 'rspec', '~> 3.2'
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: uh-layout
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Thibault Jouan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-04 00:00:00.000000000 Z
+date: 2015-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uh
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -60,23 +60,28 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
-- Gemfile-custom.rb
 - Guardfile
 - Rakefile
 - lib/uh/layout.rb
+- lib/uh/layout/arrangers/fixed_width.rb
+- lib/uh/layout/arrangers/stack.rb
+- lib/uh/layout/arrangers/vert_tile.rb
 - lib/uh/layout/bar.rb
+- lib/uh/layout/client_column_mover.rb
 - lib/uh/layout/column.rb
-- lib/uh/layout/column/arranger.rb
 - lib/uh/layout/container.rb
 - lib/uh/layout/dumper.rb
-- lib/uh/layout/geo_accessors.rb
 - lib/uh/layout/screen.rb
 - lib/uh/layout/tag.rb
 - lib/uh/layout/version.rb
 - spec/spec_helper.rb
 - spec/support/factories.rb
-- spec/uh/layout/column/arranger_spec.rb
+- spec/uh/layout/arrangers/fixed_width_spec.rb
+- spec/uh/layout/arrangers/stack_spec.rb
+- spec/uh/layout/arrangers/vert_tile_spec.rb
+- spec/uh/layout/client_column_mover_spec.rb
 - spec/uh/layout/column_spec.rb
 - spec/uh/layout/container_spec.rb
 - spec/uh/layout/screen_spec.rb
@@ -109,7 +114,10 @@ summary: Simple layout for uh
 test_files:
 - spec/spec_helper.rb
 - spec/support/factories.rb
-- spec/uh/layout/column/arranger_spec.rb
+- spec/uh/layout/arrangers/fixed_width_spec.rb
+- spec/uh/layout/arrangers/stack_spec.rb
+- spec/uh/layout/arrangers/vert_tile_spec.rb
+- spec/uh/layout/client_column_mover_spec.rb
 - spec/uh/layout/column_spec.rb
 - spec/uh/layout/container_spec.rb
 - spec/uh/layout/screen_spec.rb

data/Gemfile-custom.rb

@@ -1,7 +0,0 @@
-group :development, :test do
-  gem 'uh', path: "#{ENV['HOME']}/src/my/uh"
-  gem 'pry'
-  gem 'listen',         require: false, path: "#{ENV['HOME']}/src/sys/listen"
-  gem 'rb-kqueue',      require: false
-  gem 'guard-rspec',    require: false
-end

data/lib/uh/layout/column/arranger.rb

@@ -1,66 +0,0 @@
-module Uh
-  class Layout
-    class Column
-      class Arranger
-        OPTIMAL_WIDTH = 484
-
-        attr_reader :columns, :geo
-
-        def initialize(columns, geo, column_width: OPTIMAL_WIDTH)
-          @columns      = columns
-          @geo          = geo
-          @column_width = column_width
-        end
-
-        def redraw
-          purge
-          update_geos
-          yield if block_given?
-        end
-
-        def purge
-          @columns.remove_if &:empty?
-        end
-
-        def move_current_client(direction)
-          return self unless @columns.current.current_client
-          @columns.current.remove client = @columns.current.current_client
-          dest_column = get_or_create_column direction
-          dest_column << client
-          dest_column.current_client = client
-          purge
-          @columns.current = dest_column
-          self
-        end
-
-        def get_or_create_column(direction)
-          if candidate = @columns.get(direction)
-            candidate
-          elsif max_columns_count?
-            @columns.get direction, cycle: true
-          else
-            Column.new(@geo).tap do |o|
-              case direction
-              when :pred then @columns.unshift o
-              when :succ then @columns << o
-              end
-            end
-          end
-        end
-
-        def max_columns_count?
-          (@geo.width / (@columns.size + 1)) < @column_width
-        end
-
-        def update_geos
-          return if @columns.empty?
-          @columns.each_with_index do |column, i|
-            column.x      = @column_width * i + @geo.x
-            column.width  = @column_width
-          end
-          @columns.last.width = @geo.width - (@columns.last.x - @geo.x)
-        end
-      end
-    end
-  end
-end

data/lib/uh/layout/geo_accessors.rb

@@ -1,10 +0,0 @@
-module Uh
-  class Layout
-    module GeoAccessors
-      extend Forwardable
-      def_delegators :@geo,
-        :x, :y, :width, :height,
-        :x=, :y=, :width=, :height=
-    end
-  end
-end

data/spec/uh/layout/column/arranger_spec.rb

@@ -1,181 +0,0 @@
-module Uh
-  class Layout
-    class Column
-      describe Arranger do
-        let(:geo)           { build_geo }
-        let(:client)        { build_client }
-        let(:column_width)  { 300 }
-        let(:column)        { Column.new(geo) }
-        let(:columns)       { Container.new([column]) }
-        subject(:arranger)  { described_class.new columns, geo,
-                                column_width: column_width }
-
-        describe '#redraw' do
-          it 'purges columns' do
-            expect(arranger).to receive :purge
-            arranger.redraw
-          end
-
-          it 'updates columns geo' do
-            expect(arranger).to receive :update_geos
-            arranger.redraw
-          end
-
-          it 'yields given block' do
-            expect { |b| arranger.redraw &b }.to yield_control
-          end
-        end
-
-        describe '#purge' do
-          it 'removes empty columns' do
-            arranger.purge
-            expect(columns).to be_empty
-          end
-        end
-
-        describe '#move_current_client' do
-          shared_examples 'moves current client' do |expected_column_index|
-            it 'removes current client from origin column' do
-              arranger.move_current_client :succ
-              expect(column).not_to include client
-            end
-
-            it 'adds current client in the destination column' do
-              arranger.move_current_client :succ
-              expect(columns[expected_column_index]).to include client
-            end
-
-            it 'updates destination column as the current one' do
-              arranger.move_current_client :succ
-              expect(columns.current).to be columns[expected_column_index]
-            end
-
-            it 'preserves current client as the current one' do
-              expect { arranger.move_current_client :succ }
-                .not_to change { columns.current.current_client }
-            end
-
-            it 'does not leave empty columns' do
-              expect(columns.none? &:empty?).to be true
-            end
-          end
-
-          it 'returns self' do
-            expect(arranger.move_current_client :succ).to be arranger
-          end
-
-          context 'given one column with one client' do
-            before { column << client }
-
-            include_examples 'moves current client', 0
-          end
-
-          context 'given one column with many clients' do
-            before { column << client << client.dup }
-
-            include_examples 'moves current client', 1
-          end
-
-          context 'given two columns' do
-            let(:columns) { Container.new([column, Column.new(geo)]) }
-
-            before { columns[1] << client.dup }
-
-            context 'when origin column has many clients' do
-              before { column << client << client.dup }
-
-              include_examples 'moves current client', 1
-            end
-
-            context 'when origin column has one client' do
-              before { column << client }
-
-              include_examples 'moves current client', 0
-            end
-          end
-        end
-
-        describe '#get_or_create_column' do
-          let(:columns) { Container.new([column, Column.new(geo)]) }
-
-          it 'returns the consecutive column in given direction' do
-            expect(arranger.get_or_create_column :succ).to be columns[1]
-          end
-
-          context 'when current column is last in given direction' do
-            before { columns.current = columns[1] }
-
-            context 'when max columns count is not reached' do
-              before { geo.width = 4096 }
-
-              it 'appends a new column' do
-                expect(arranger.get_or_create_column :succ).to be columns[2]
-              end
-
-              it 'prepends a new column' do
-                columns.current = columns[0]
-                expect(arranger.get_or_create_column :pred).to be columns[0]
-              end
-            end
-
-            context 'when max columns count is reached' do
-              it 'returns the consecutive column in given direction' do
-                expect(arranger.get_or_create_column :succ).to be columns[0]
-              end
-            end
-          end
-        end
-
-        describe '#max_columns_count?' do
-          context 'when a new column fits in current geo' do
-            it 'returns false' do
-              expect(arranger.max_columns_count?).to be false
-            end
-          end
-
-          context 'when current geo can not contain more column' do
-            let(:columns) { Container.new([column, Column.new(geo)]) }
-
-            it 'returns true' do
-              expect(arranger.max_columns_count?).to be true
-            end
-          end
-        end
-
-        describe '#update_geos' do
-          let(:columns) { Container.new([column, Column.new(geo)]) }
-
-          before { geo.x = 20 }
-
-          it 'decreases first column width as the optimal column width' do
-            arranger.update_geos
-            expect(columns[0].width).to eq 300
-          end
-
-          it 'offsets each column with given geo' do
-            arranger.update_geos
-            expect(columns[0].x).to eq 20
-          end
-
-          it 'moves second column aside the first column' do
-            arranger.update_geos
-            expect(columns[1].x).to eq 320
-          end
-
-          it 'increases last column width to occupy remaining width' do
-            arranger.update_geos
-            expect(columns[1].width).to eq 340
-          end
-
-          context 'without columns' do
-            let(:columns) { Container.new([]) }
-
-            it 'does not raise any error' do
-              expect { arranger.update_geos }.not_to raise_error
-            end
-          end
-        end
-      end
-    end
-  end
-end