uh-wm 0.0.2.pre → 0.0.2

data/spec/uh/wm/client_spec.rb

@@ -0,0 +1,133 @@
+module Uh
+  module WM
+    RSpec.describe Client do
+      let(:geo)         { Geo.new(0, 0, 640, 480) }
+      let(:window) do
+        instance_spy Window, 'window', to_s: 'wid',
+          name: 'wname', wclass: 'wclass'
+      end
+      subject(:client)  { described_class.new window, geo }
+
+      it 'is not visible' do
+        expect(client).not_to be_visible
+      end
+
+      it 'is hidden' do
+        expect(client).to be_hidden
+      end
+
+      it 'has an unmap count of 0' do
+        expect(client.unmap_count).to eq 0
+      end
+
+      describe '#to_s' do
+        it 'includes window name' do
+          expect(client.to_s).to include 'wname'
+        end
+
+        it 'includes window class' do
+          expect(client.to_s).to include 'wclass'
+        end
+
+        it 'includes geo' do
+          expect(client.to_s).to include geo.to_s
+        end
+
+        it 'includes window id' do
+          expect(client.to_s).to include 'wid'
+        end
+      end
+
+      describe '#name' do
+        it 'returns the window name' do
+          expect(client.name).to eq window.name
+        end
+      end
+
+      describe '#wclass' do
+        it 'returns the window class' do
+          expect(client.wclass).to eq window.wclass
+        end
+      end
+
+      describe '#configure' do
+        it 'configures the window with client geo' do
+          expect(window).to receive(:configure).with geo
+          client.configure
+        end
+
+        it 'returns self' do
+          expect(client.configure).to be client
+        end
+      end
+
+      describe '#moveresize' do
+        it 'moveresizes the window with client geo' do
+          expect(window).to receive(:moveresize).with geo
+          client.moveresize
+        end
+
+        it 'returns self' do
+          expect(client.moveresize).to be client
+        end
+      end
+
+      describe '#show' do
+        it 'maps the window' do
+          expect(window).to receive :map
+          client.show
+        end
+
+        it 'toggles the client as visible' do
+          expect { client.show }
+            .to change { client.visible? }
+            .from(false).to true
+        end
+
+        it 'returns self' do
+          expect(client.show).to be client
+        end
+      end
+
+      describe '#hide' do
+        it 'unmaps the window' do
+          expect(window).to receive :unmap
+          client.hide
+        end
+
+        it 'toggles the client as hidden' do
+          client.show
+          expect { client.hide }
+            .to change { client.hidden? }
+            .from(false).to true
+        end
+
+        it 'increments the unmap count' do
+          expect { client.hide }
+            .to change { client.unmap_count }
+            .from(0).to 1
+        end
+
+        it 'returns self' do
+          expect(client.hide).to be client
+        end
+      end
+
+      describe '#focus' do
+        it 'raises the window' do
+          expect(window).to receive :raise
+          client.focus
+        end
+
+        it 'focuses the window' do
+          expect(window).to receive :focus
+          client.focus
+        end
+
+        it 'returns self' do
+          expect(client.focus).to be client
+        end
+      end
+    end
+  end
+end

data/spec/uh/wm/dispatcher_spec.rb

@@ -0,0 +1,76 @@
+module Uh
+  module WM
+    RSpec.describe Dispatcher do
+      subject(:dispatcher)  { described_class.new }
+
+      describe '#[]' do
+        context 'when given key for existing hook' do
+          before { dispatcher.hooks[:hook_key] = [:hook] }
+
+          it 'returns registered hooks for this key' do
+            expect(dispatcher[:hook_key]).to eq [:hook]
+          end
+        end
+
+        context 'when given multiple keys for existing hook' do
+          before { dispatcher.hooks[%i[hook key]] = [:hook] }
+
+          it 'returns registered hooks for this key' do
+            expect(dispatcher[:hook, :key]).to eq [:hook]
+          end
+        end
+
+        context 'when given key for unknown hook' do
+          it 'returns an empty array' do
+            expect(dispatcher[:unknown_hook]).to eq []
+          end
+        end
+      end
+
+      describe '#on' do
+        it 'registers given hook for given key' do
+          dispatcher.on(:hook_key) { :hook }
+          expect(dispatcher.hooks[:hook_key]).to be
+        end
+
+        it 'registers given hook for given multiple keys' do
+          dispatcher.on(:hook, :key) { :hook }
+          expect(dispatcher.hooks[%i[hook key]]).to be
+        end
+      end
+
+      describe '#emit' do
+        it 'calls hooks registered for given key' do
+          dispatcher.on(:hook_key) { throw :hook_code }
+          expect { dispatcher.emit :hook_key }.to throw_symbol :hook_code
+        end
+
+        it 'returns the value returned by a registered hook' do
+          dispatcher.on(:hook_key) { :hook_code }
+          expect(dispatcher.emit :hook_key).to eq :hook_code
+        end
+
+        context 'when no hooks are registered for given key' do
+          it 'does not call another hook' do
+            dispatcher.on(:hook_key) { throw :hook_code }
+            expect { dispatcher.emit :other_hook_key }.not_to throw_symbol
+          end
+        end
+
+        context 'when no hooks are registered at all' do
+          it 'does not raise any error' do
+            expect { dispatcher.emit :hook_key }.not_to raise_error
+          end
+        end
+
+        context 'when args keyword argument is given' do
+          it 'calls hooks with given args' do
+            dispatcher.on(:hook_key) { |arg1, arg2| throw arg2 }
+            expect { dispatcher.emit :hook_key, args: %i[arg1 arg2] }
+              .to throw_symbol :arg2
+          end
+        end
+      end
+    end
+  end
+end

data/spec/uh/wm/env_spec.rb

@@ -0,0 +1,145 @@
+module Uh
+  module WM
+    RSpec.describe Env do
+      let(:output)  { StringIO.new }
+      let(:logger)  { Logger.new(StringIO.new) }
+      subject(:env) { described_class.new output }
+
+      it 'has verbose mode disabled' do
+        expect(env).not_to be_verbose
+      end
+
+      it 'has debug mode disabled' do
+        expect(env).not_to be_debug
+      end
+
+      it 'has the default rc path set' do
+        expect(env.rc_path).to eq '~/.uhwmrc.rb'
+      end
+
+      it 'has no layout_class set' do
+        expect(env.layout_class).not_to be
+      end
+
+      it 'has the default modifier set' do
+        expect(env.modifier).to eq :mod1
+      end
+
+      it 'has default key binding for quit set' do
+        expect(env.keybinds.keys).to include [:q, :shift]
+      end
+
+      it 'has the blocking worker by default' do
+        expect(env.worker).to eq :block
+      end
+
+      describe '#verbose?' do
+        context 'when verbose mode is disabled' do
+          before { env.verbose = false }
+
+          it 'returns false' do
+            expect(env.verbose?).to be false
+          end
+        end
+
+        context 'when verbose mode is enabled' do
+          before { env.verbose = true }
+
+          it 'returns true' do
+            expect(env.verbose?).to be true
+          end
+        end
+      end
+
+      describe '#debug?' do
+        context 'when debug mode is disabled' do
+          before { env.debug = false }
+
+          it 'returns false' do
+            expect(env.debug?).to be false
+          end
+        end
+
+        context 'when debug mode is enabled' do
+          before { env.debug = true }
+
+          it 'returns true' do
+            expect(env.debug?).to be true
+          end
+        end
+      end
+
+      describe '#layout' do
+        context 'when a layout class is set' do
+          let(:some_layout) { Class.new }
+
+          before { env.layout_class = some_layout }
+
+          it 'returns a new instance of this layout class' do
+            expect(env.layout).to be_an_instance_of some_layout
+          end
+        end
+
+        context 'when a layout class is not set' do
+          it 'returns an instance of the default layout' do
+            expect(env.layout).to be_an_instance_of ::Uh::Layout
+          end
+        end
+      end
+
+      describe '#logger' do
+        it 'returns a logger' do
+          expect(env.logger).to be_a Logger
+        end
+
+        it 'has logger level warn set' do
+          expect(env.logger.level).to be Logger::WARN
+        end
+
+        context 'when verbose mode is enabled' do
+          before { env.verbose = true }
+
+          it 'has logger level info set' do
+            expect(env.logger.level).to be Logger::INFO
+          end
+        end
+
+        context 'when debug mode is enabled' do
+          before { env.debug = true }
+
+          it 'has logger level debug set' do
+            expect(env.logger.level).to be Logger::DEBUG
+          end
+        end
+      end
+
+      describe '#log' do
+        it 'logs given message at info level' do
+          expect(env.logger).to receive(:info).with 'some message'
+          env.log 'some message'
+        end
+      end
+
+      describe '#log_debug' do
+        it 'logs given message at debug level' do
+          expect(env.logger).to receive(:debug).with 'some message'
+          env.log_debug 'some message'
+        end
+      end
+
+      describe '#log_logger_level' do
+        it 'logs the logger level' do
+          expect(env.logger).to receive(:info).with /log.+(warn|info|debug).+level/i
+          env.log_logger_level
+        end
+      end
+
+      describe '#print' do
+        it 'prints the message to the output' do
+          env.print 'some message'
+          expect(output.string).to eq 'some message'
+        end
+      end
+    end
+  end
+end

data/spec/uh/wm/manager_spec.rb

@@ -0,0 +1,355 @@
+module Uh
+  module WM
+    RSpec.describe Manager do
+      let(:block)       { proc { } }
+      let(:window)      { instance_spy Window, override_redirect?: false }
+      let(:events)      { Dispatcher.new }
+      let(:modifier)    { :mod1 }
+      let(:display)     { Display.new }
+      subject(:manager) { described_class.new events, modifier, display }
+
+      it 'has a new display' do
+        expect(manager.display).to be_a Display
+      end
+
+      it 'has no clients' do
+        expect(manager.clients).to be_empty
+      end
+
+      describe '#to_io', :xvfb do
+        context 'when connected' do
+          before { manager.connect }
+
+          it 'returns an IO object wrapping the display file descriptor' do
+            expect(manager.to_io)
+              .to be_an(IO)
+              .and have_attributes(fileno: display.fileno)
+          end
+        end
+      end
+
+      describe '#connect', :xvfb do
+        it 'opens the display' do
+          expect(manager.display).to receive(:open).and_call_original
+          manager.connect
+        end
+
+        it 'emits :connecting event with the display' do
+          events.on :connecting, &block
+          expect(block).to receive(:call) do |*args|
+            expect(args).to eq [display]
+          end
+          manager.connect
+        end
+
+        it 'emits :connected event with the display' do
+          events.on :connected, &block
+          expect(block).to receive(:call) do |*args|
+            expect(args).to eq [display]
+          end
+          manager.connect
+        end
+
+        it 'updates the root window mask in order to manage windows' do
+          manager.connect
+          expect(display.root.mask).to eq Events::PROPERTY_CHANGE_MASK |
+            Events::SUBSTRUCTURE_REDIRECT_MASK |
+            Events::SUBSTRUCTURE_NOTIFY_MASK |
+            Events::STRUCTURE_NOTIFY_MASK
+        end
+
+        context 'when connection fails' do
+          before { allow(display).to receive(:open) { fail } }
+
+          it 'does not emit :connected event' do
+            events.on :connected, &block
+            expect(block).not_to receive :call
+            manager.connect rescue nil
+          end
+        end
+      end
+
+      describe '#disconnect' do
+        it 'closes the display' do
+          expect(display).to receive :close
+          manager.disconnect
+        end
+
+        it 'emits :disconnected event' do
+          allow(display).to receive :close
+          events.on :disconnected, &block
+          expect(block).to receive :call
+          manager.disconnect
+        end
+      end
+
+      describe '#flush' do
+        it 'flushes the display' do
+          expect(display).to receive :flush
+          manager.flush
+        end
+      end
+
+      describe '#grab_key' do
+        it 'grabs given key on the display' do
+          expect(manager.display)
+            .to receive(:grab_key).with('f', KEY_MODIFIERS[modifier])
+          manager.grab_key :f
+        end
+
+        context 'when a modifier is given' do
+          it 'grabs the key with given modifier' do
+            expect(manager.display)
+              .to receive(:grab_key)
+              .with('f', KEY_MODIFIERS[modifier] | KEY_MODIFIERS[:shift])
+            manager.grab_key :f, :shift
+          end
+        end
+      end
+
+      describe '#configure' do
+        context 'with new window' do
+          it 'sends a configure event to the window with a default geo' do
+            expect(window)
+              .to receive(:configure_event).with(Geo.new(0, 0, 320, 240))
+            manager.configure window
+          end
+
+          context 'when :configure event returns a geo' do
+            it 'sends a configure event with geo returned by event' do
+              geo = Geo.new(0, 0, 42, 42)
+              events.on(:configure) { geo }
+              expect(window).to receive(:configure_event).with geo
+              manager.configure window
+            end
+          end
+        end
+
+        context 'with known window' do
+          before { manager.map window }
+
+          it 'tells the client to configure' do
+            expect(manager.clients[0]).to receive :configure
+            manager.configure window
+          end
+        end
+      end
+
+      describe '#map' do
+        it 'registers a new client wrapping the given window' do
+          manager.map window
+          expect(manager.clients[0])
+            .to be_a(Client)
+            .and have_attributes(window: window)
+        end
+
+        it 'registers new client only once for a given window' do
+          manager.map window
+          expect { manager.map window }.not_to change { manager.clients }
+        end
+
+        it 'ignores event when window has override redirect' do
+          allow(window).to receive(:override_redirect?) { true }
+          expect { manager.map window }.not_to change { manager.clients }
+        end
+
+        it 'emits :manage event with the registered client' do
+          events.on :manage, &block
+          expect(block).to receive :call do |client|
+            expect(client)
+              .to be_a(Client)
+              .and have_attributes(window: window)
+          end
+          manager.map window
+        end
+      end
+
+      describe '#unmap' do
+        before { manager.map window }
+
+        context 'when client unmap count is 0 or less' do
+          it 'preserves the client unmap count' do
+            client = manager.clients[0]
+            expect { manager.unmap window }
+              .not_to change { client.unmap_count }
+          end
+
+          it 'unregisters the client' do
+            expect { manager.unmap window }
+              .to change { manager.clients.size }.from(1).to 0
+          end
+
+          it 'emits :unmanage event with the client' do
+            events.on :unmanage, &block
+            expect(block).to receive(:call).with manager.clients[0]
+            manager.unmap window
+          end
+        end
+
+        context 'when client unmap count is strictly positive' do
+          before { manager.clients[0].unmap_count += 1 }
+
+          it 'does not unregister the client' do
+            expect { manager.unmap window }.not_to change { manager.clients }
+          end
+
+          it 'decrements the unmap count' do
+            manager.unmap window
+            expect(manager.clients[0].unmap_count).to eq 0
+          end
+        end
+
+        context 'with unknown window' do
+          let(:unknown_window) { window.dup }
+
+          it 'does not change registered clients' do
+            expect { manager.unmap unknown_window }
+              .not_to change { manager.clients }
+          end
+
+          it 'does not emit any event' do
+            expect(events).not_to receive :emit
+            manager.unmap unknown_window
+          end
+        end
+      end
+
+      describe '#destroy' do
+        before { manager.map window }
+
+        it 'unregisters the client' do
+          expect { manager.destroy window }
+            .to change { manager.clients.size }.from(1).to 0
+        end
+
+        it 'emits :unmanage event with the client' do
+          events.on :unmanage, &block
+          expect(block).to receive(:call).with manager.clients[0]
+          manager.destroy window
+        end
+
+        context 'with unknown window' do
+          let(:unknown_window) { window.dup }
+
+          it 'does not change registered clients' do
+            expect { manager.destroy unknown_window }
+              .not_to change { manager.clients }
+          end
+
+          it 'does not emit any event' do
+            expect(events).not_to receive :emit
+            manager.destroy unknown_window
+          end
+        end
+      end
+
+      describe '#handle_next_event' do
+        it 'handles the next available event on display' do
+          event = double 'event'
+          allow(display).to receive(:next_event) { event }
+          expect(manager).to receive(:handle).with(event).once
+          manager.handle_next_event
+        end
+      end
+
+      describe '#handle_pending_events' do
+        let(:event) { double 'event' }
+
+        context 'when an event is pending on display' do
+          before do
+            allow(display).to receive(:pending?).and_return true, false
+            allow(display).to receive(:next_event) { event }
+          end
+
+          it 'handles the event' do
+            expect(manager).to receive(:handle).with(event).once
+            manager.handle_pending_events
+          end
+        end
+
+        context 'when multiple events are pending on display' do
+          before do
+            allow(display).to receive(:pending?).and_return true, true, false
+            allow(display).to receive(:next_event) { event }
+          end
+
+          it 'handles all pending events' do
+            expect(manager).to receive(:handle).with(event).twice
+            manager.handle_pending_events
+          end
+        end
+      end
+
+      describe '#handle' do
+        let(:event) { double 'event', type: :any }
+
+        it 'emits :xevent event with the X event' do
+          events.on :xevent, &block
+          manager.handle event
+        end
+
+        context 'when key_press event is given' do
+          let(:mod_mask) { KEY_MODIFIERS[modifier] }
+          let(:event) do
+            double 'event',
+              type:           :key_press,
+              key:            'f',
+              modifier_mask:  mod_mask
+          end
+
+          it 'emits :key event with the corresponding key' do
+            events.on(:key, :f) { throw :key_press_code }
+            expect { manager.handle event }.to throw_symbol :key_press_code
+          end
+
+          context 'whith shift key modifier' do
+            let(:mod_mask) { KEY_MODIFIERS[modifier] | KEY_MODIFIERS[:shift] }
+
+            it 'emits :key event with the corresponding key and :shift' do
+              events.on(:key, :f, :shift) { throw :key_press_code }
+              expect { manager.handle event }.to throw_symbol :key_press_code
+            end
+          end
+        end
+
+        context 'when configure request event is given' do
+          let(:event) do
+            double 'event', type: :configure_request, window: :window
+          end
+
+          it 'configures the event window' do
+            expect(manager).to receive(:configure).with :window
+            manager.handle event
+          end
+        end
+
+        context 'when destroy_notify event is given' do
+          let(:event) { double 'event', type: :destroy_notify, window: :window }
+
+          it 'destroy the event window' do
+            expect(manager).to receive(:destroy).with :window
+            manager.handle event
+          end
+        end
+
+        context 'when map_request event is given' do
+          let(:event) { double 'event', type: :map_request, window: :window }
+
+          it 'maps the event window' do
+            expect(manager).to receive(:map).with :window
+            manager.handle event
+          end
+        end
+
+        context 'when unmap_notify event is given' do
+          let(:event) { double 'event', type: :unmap_notify, window: :window }
+
+          it 'unmap the event window' do
+            expect(manager).to receive(:unmap).with :window
+            manager.handle event
+          end
+        end
+      end
+    end
+  end
+end