uh-layout 0.1.1

data/lib/uh/layout/container.rb

@@ -0,0 +1,75 @@
+module Uh
+  class Layout
+    class Container
+      include Enumerable
+
+      extend Forwardable
+      def_delegators :@entries, :<<, :[], :each, :empty?, :first, :index, :last,
+        :size, :unshift
+
+      def initialize(entries = [])
+        @entries        = entries
+        @current_index  = 0
+      end
+
+      alias to_ary entries
+
+      def current
+        @entries[@current_index]
+      end
+
+      def current=(entry)
+        @current_index = @entries.index entry if include? entry
+      end
+
+      def remove(entry)
+        fail ArgumentError, 'unknown entry' unless include? entry
+        @entries.delete_at @entries.index entry
+        @current_index -= 1 unless @current_index == 0
+        self
+      end
+
+      def remove_if
+        @entries.each { |e| remove e if yield e }
+      end
+
+      def get(direction, cycle: false)
+        index = @current_index.send direction
+        if cycle
+          @entries[index % @entries.size]
+        else
+          index >= 0 ? self[index] : nil
+        end
+      end
+
+      def sel(direction)
+        @current_index = @current_index.send(direction) % @entries.size
+      end
+
+      def set(direction)
+        new_index = @current_index.send direction
+        if new_index.between? 0, @entries.size - 1
+          swap @current_index, new_index
+          @current_index = new_index
+        else
+          rotate direction
+          @current_index = new_index % @entries.size
+        end
+      end
+
+      def swap(a, b)
+        @entries[a], @entries[b] = @entries[b], @entries[a]
+      end
+
+
+      private
+
+      def rotate(direction)
+        case direction
+        when :pred then @entries = @entries.push    @entries.shift
+        when :succ then @entries = @entries.unshift @entries.pop
+        end
+      end
+    end
+  end
+end

data/lib/uh/layout/dumper.rb

@@ -0,0 +1,28 @@
+module Uh
+  class Layout
+    class Dumper
+      def initialize(layout)
+        @layout = layout
+      end
+
+      def to_s
+        @layout.screens.inject('') do |m, screen|
+          m << "%s%s\n" % [@layout.current_screen?(screen) ? '*' : ' ', screen]
+          screen.tags.each do |tag|
+            m << "  %s%s\n" % [screen.current_tag?(tag) ? '*' : ' ', tag]
+            tag.columns.each do |column|
+              m << "    %s%s\n" % [tag.current_column?(column) ? '*' : ' ', column]
+              column.clients.each do |client|
+                m << "      %s%s\n" % [
+                  column.current_client?(client) ? '*' : ' ',
+                  client
+                ]
+              end
+            end
+          end
+          m
+        end
+      end
+    end
+  end
+end

data/lib/uh/layout/geo_accessors.rb

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

data/lib/uh/layout/screen.rb

@@ -0,0 +1,32 @@
+module Uh
+  class Layout
+    class Screen
+      include GeoAccessors
+
+      extend Forwardable
+      def_delegator :@tags, :current, :current_tag
+      def_delegator :current_tag, :==, :current_tag?
+
+      attr_reader :id, :tags, :geo
+
+      def initialize(id, geo)
+        @id   = id
+        @geo  = geo.dup
+        @tags = Container.new([Tag.new('1', @geo)])
+      end
+
+      def to_s
+        "SCREEN ##{@id}, geo: #{@geo}"
+      end
+
+      def height=(value)
+        @geo.height = value
+        @tags.each { |tag| tag.height = value }
+      end
+
+      def include?(client)
+        @tags.any? { |tag| tag.include? client }
+      end
+    end
+  end
+end

data/lib/uh/layout/tag.rb

@@ -0,0 +1,47 @@
+module Uh
+  class Layout
+    class Tag
+      include GeoAccessors
+
+      extend Forwardable
+      def_delegator :@columns, :current, :current_column
+      def_delegator :@columns, :current=, :current_column=
+      def_delegator :@columns, :each, :each_column
+      def_delegator :current_column, :==, :current_column?
+      def_delegator :clients, :each, :each_client
+
+      attr_reader :id, :geo, :columns
+
+      def initialize(id, geo)
+        unless id.kind_of? String
+          fail ArgumentError, "expect `id' to be a String, #{id.class} given"
+        end
+        @id       = id
+        @geo      = geo.dup
+        @columns  = Container.new
+      end
+
+      def to_s
+        "TAG ##{@id}, geo: #{@geo}"
+      end
+
+      def clients
+        @columns.inject([]) { |m, column| m + column.clients }
+      end
+
+      def include?(client)
+        @columns.any? { |column| column.include? client }
+      end
+
+      def current_column_or_create
+        current_column or Column.new(@geo).tap do |column|
+          @columns << column
+        end
+      end
+
+      def hide
+        clients.each &:hide
+      end
+    end
+  end
+end

data/lib/uh/layout/version.rb

@@ -0,0 +1,5 @@
+module Uh
+  class Layout
+    VERSION = '0.1.1'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'uh'
+require 'uh/wm'
+require 'uh/layout'
+
+Dir['spec/support/**/*.rb'].map { |e| require e.gsub 'spec/', '' }
+
+RSpec::Matchers.define_negated_matcher :not_be, :be
+
+RSpec.configure do |config|
+  config.include Factories
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles = true
+  end
+end

data/spec/support/factories.rb

@@ -0,0 +1,9 @@
+module Factories
+  def build_client
+    Uh::WM::Client.new(instance_spy Uh::Window)
+  end
+
+  def build_geo(x = 0, y = 0, width = 640, height = 480)
+    Uh::Geo.new(x, y, width, height)
+  end
+end

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

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

data/spec/uh/layout/column_spec.rb

@@ -0,0 +1,66 @@
+module Uh
+  class Layout
+    describe Column do
+      let(:geo)           { build_geo }
+      let(:other_geo)     { build_geo 640, 0, 320, 240 }
+      let(:client)        { build_client }
+      let(:other_client)  { build_client }
+      subject(:column)    { described_class.new(geo) }
+
+      it 'has a copy to given geo' do
+        expect(column.geo).to eq(geo).and not_be geo
+      end
+
+      it 'has no client assigned' do
+        expect(column).to be_empty
+      end
+
+      describe '#<<' do
+        before { column << client }
+
+        it 'assigns column geo copy to given client' do
+          expect(client.geo).to eq(column.geo).and not_be column.geo
+        end
+
+        it 'adds given client' do
+          expect(column.clients).to include client
+        end
+
+        it 'returns self' do
+          expect(column << client).to be column
+        end
+      end
+
+      describe '#arrange_clients' do
+        before { column << client << other_client }
+
+        it 'updates clients geometries' do
+          column.width = 320
+          column.arrange_clients
+          expect(column.clients.map(&:geo)).to all eq column.geo
+        end
+
+        it 'moveresizes clients' do
+          expect([client, other_client]).to all receive :moveresize
+          column.arrange_clients
+        end
+      end
+
+      describe '#show_hide_clients' do
+        before { column << client << other_client }
+
+        it 'shows current client only' do
+          expect(other_client).not_to receive :show
+          expect(client.hide).to receive :show
+          column.show_hide_clients
+        end
+
+        it 'hides non-current clients' do
+          expect(client).not_to receive :hide
+          expect(other_client.show).to receive :hide
+          column.show_hide_clients
+        end
+      end
+    end
+  end
+end