uh-wm 0.0.6 → 0.0.7

data/spec/uh/wm/manager_spec.rb

@@ -1,386 +0,0 @@
-module Uh
-  module WM
-    RSpec.describe Manager do
-      let(:block)       { proc { } }
-      let(:window)      { mock_window }
-      let(:client)      { build_client window }
-      let(:events)      { Dispatcher.new }
-      let(:modifier)    { :mod1 }
-      let(:display)     { Display.new }
-      subject(:manager) { described_class.new events, modifier, display }
-
-      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(build_geo 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 = build_geo 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.clients << client }
-
-          it 'tells the client to configure' do
-            expect(client).to receive :configure
-            manager.configure window
-          end
-        end
-      end
-
-      describe '#map' do
-        let(:display) { instance_spy Display }
-
-        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
-
-        it 'listens for property notify events on given window' do
-          expect(display)
-            .to receive(:listen_events)
-            .with window, Events::PROPERTY_CHANGE_MASK
-          manager.map window
-        end
-      end
-
-      describe '#unmap' do
-        before { manager.clients << client }
-
-        context 'when client unmap count is 0 or less' do
-          it 'preserves the client unmap count' do
-            expect { manager.unmap window }.not_to change { client.unmap_count }
-          end
-
-          it 'unregisters the client' do
-            manager.unmap window
-            expect(manager.clients).not_to include client
-          end
-
-          it 'emits :unmanage event with the client' do
-            events.on :unmanage, &block
-            expect(block).to receive(:call).with client
-            manager.unmap window
-          end
-        end
-
-        context 'when client unmap count is strictly positive' do
-          before { client.unmap_count += 1 }
-
-          it 'does not unregister the client' do
-            manager.unmap window
-            expect(manager.clients).to include client
-          end
-
-          it 'decrements the unmap count' do
-            manager.unmap window
-            expect(client.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.clients << client }
-
-        it 'unregisters the client' do
-          manager.destroy window
-          expect(manager.clients).not_to include client
-        end
-
-        it 'emits :unmanage event with the client' do
-          events.on :unmanage, &block
-          expect(block).to receive(:call).with client
-          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 '#update_properties' do
-        context 'with known window' do
-          before { manager.clients << client }
-
-          it 'tells the client to update its window properties' do
-            expect(client).to receive :update_window_properties
-            manager.update_properties window
-          end
-
-          it 'emits :change event with the client' do
-            events.on :change, &block
-            expect(block).to receive(:call).with client
-            manager.update_properties window
-          end
-        end
-
-        context 'with unknown window' do
-          it 'does not emit any event' do
-            expect(events).not_to receive :emit
-            manager.update_properties 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) { mock_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) { mock_event }
-
-        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)     { mock_event_key_press 'f', mod_mask }
-
-          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) { mock_event :configure_request, window: :window }
-
-          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) { mock_event :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) { mock_event :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) { mock_event :unmap_notify, window: :window }
-
-          it 'unmaps the event window' do
-            expect(manager).to receive(:unmap).with :window
-            manager.handle event
-          end
-        end
-
-        context 'when property_notify event is given' do
-          let(:event) { mock_event :property_notify, window: :window }
-
-          it 'updates event window properties' do
-            expect(manager).to receive(:update_properties).with :window
-            manager.handle event
-          end
-        end
-      end
-    end
-  end
-end

data/spec/uh/wm/run_control_spec.rb

@@ -1,126 +0,0 @@
-require 'support/filesystem_helpers'
-
-module Uh
-  module WM
-    RSpec.describe RunControl do
-      include FileSystemHelpers
-
-      let(:env)     { Env.new(StringIO.new) }
-      subject(:rc)  { described_class.new env }
-
-      describe '.evaluate' do
-        around do |example|
-          with_file ':run_control_code' do |f|
-            env.rc_path = f.path
-            example.run
-          end
-        end
-
-        it 'builds a new instance with given env' do
-          expect(described_class).to receive(:new).with(env).and_call_original
-          described_class.evaluate env
-        end
-
-        it 'tells the new instance to evaluate run control file content' do
-          expect(rc)
-            .to receive(:evaluate).with(':run_control_code', env.rc_path)
-          allow(described_class).to receive(:new) { rc }
-          described_class.evaluate env
-        end
-
-        context 'when run control file is not present' do
-          before { env.rc_path = 'non_existent_rc_file.rb' }
-
-          it 'does not raise any error' do
-            expect { described_class.evaluate env }.not_to raise_error
-          end
-        end
-      end
-
-      describe '#evaluate' do
-        it 'evaluates given code' do
-          expect { rc.evaluate 'throw :run_control_code', 'some_path' }
-            .to throw_symbol :run_control_code
-        end
-
-        it 'provides access to assigned env' do
-          expect { rc.evaluate 'fail @env.object_id.to_s', 'some_path' }
-            .to raise_error env.object_id.to_s
-        end
-      end
-
-      describe '#modifier' do
-        it 'updates env modifier' do
-          rc.modifier :ctrl
-          expect(env.modifier).to eq :ctrl
-        end
-      end
-
-      describe '#key' do
-        let(:code) { -> { :keybind_code } }
-
-        it 'registers a key binding in the env' do
-          rc.key :f, &code
-          expect(env.keybinds.keys).to include :f
-        end
-
-        it 'registers a combined keys binding in the env' do
-          rc.key :f, :shift, &code
-          expect(env.keybinds.keys).to include %i[f shift]
-        end
-
-        it 'registers given block with the key binding' do
-          rc.key :f, &code
-          expect(env.keybinds[:f].call).to eq :keybind_code
-        end
-
-        it 'translates common key names to equivalent X keysym' do
-          rc.key :enter, &code
-          expect(env.keybinds.keys).to include :Return
-        end
-
-        it 'translates upcased key name to a combination with shift' do
-          rc.key :F, &code
-          expect(env.keybinds.keys).to include %i[f shift]
-        end
-      end
-
-      describe '#layout' do
-        context 'when given a class' do
-          let(:layout_class) { Class.new }
-
-          it 'sets a layout class in the env' do
-            rc.layout layout_class
-            expect(env.layout_class).to be layout_class
-          end
-
-          context 'when given options' do
-            it 'instantiates the class with given options' do
-              expect(layout_class).to receive(:new).with(foo: :bar)
-              rc.layout layout_class, foo: :bar
-            end
-          end
-        end
-
-        context 'when given an object' do
-          it 'sets a layout instance in the env' do
-            rc.layout layout = Object.new
-            expect(env.layout).to eq layout
-          end
-        end
-      end
-
-      describe '#worker' do
-        it 'sets the worker type in the env' do
-          rc.worker :some_worker
-          expect(env.worker[0]).to eq :some_worker
-        end
-
-        it 'sets the worker options in the env' do
-          rc.worker :some_worker, some: :option
-          expect(env.worker[1]).to eq({ some: :option })
-        end
-      end
-    end
-  end
-end

data/spec/uh/wm/runner_spec.rb

@@ -1,196 +0,0 @@
-SomeLayout = Class.new do
-  include Factories
-
-  define_method(:register)    { |*_| }
-  define_method(:suggest_geo) { build_geo 0, 0, 42, 42 }
-  define_method(:<<)          { |*_| }
-  define_method(:remove)      { |*_| }
-  define_method(:update)      { |*_| }
-end
-
-module Uh
-  module WM
-    RSpec.describe Runner do
-      let(:env)         { Env.new(StringIO.new) }
-      subject(:runner)  { described_class.new env }
-
-      before do
-        env.layout_class  = SomeLayout
-        env.rc_path       = 'non_existent_run_control.rb'
-      end
-
-      it 'has a dispatcher' do
-        expect(runner.events).to be_a Dispatcher
-      end
-
-      it 'is not stopped' do
-        expect(runner).not_to be_stopped
-      end
-
-      describe '#stopped?' do
-        context 'when not stopped' do
-          it 'returns false' do
-            expect(runner.stopped?).to be false
-          end
-        end
-
-        context 'when stopped' do
-          before { runner.stop! }
-
-          it 'returns true' do
-            expect(runner.stopped?).to be true
-          end
-        end
-      end
-
-      describe '#stop!' do
-        it 'sets the runner as stopped' do
-          expect { runner.stop! }
-            .to change { runner.stopped? }
-            .from(false).to(true)
-        end
-      end
-
-      describe '#manager' do
-        it 'returns the manager' do
-          expect(runner.manager).to be_a Manager
-        end
-
-        it 'sets the manager modifier as env modifier' do
-          expect(runner.manager.modifier).to eq env.modifier
-        end
-      end
-
-      describe '#evaluate_run_control' do
-        it 'evaluates the run control file with RunControl and current env' do
-          expect(RunControl).to receive(:evaluate).with env
-          runner.evaluate_run_control
-        end
-      end
-
-      describe '#register_event_hooks' do
-        it 'registers quit event hook' do
-          runner.register_event_hooks
-          expect(runner).to receive :stop!
-          runner.events.emit :quit
-        end
-
-        context 'layout hooks' do
-          it 'registers for :connected event' do
-            runner.register_event_hooks
-            expect(env.layout).to receive(:register).with :display
-            runner.events.emit :connected, args: :display
-          end
-
-          it 'registers for :configure event' do
-            runner.register_event_hooks
-            expect(runner.events.emit :configure, args: :window)
-              .to eq build_geo 0, 0, 42, 42
-          end
-
-          it 'registers for :manage event' do
-            runner.register_event_hooks
-            expect(env.layout).to receive(:<<).with :client
-            runner.events.emit :manage, args: :client
-          end
-
-          it 'registers for :unmanage event' do
-            runner.register_event_hooks
-            expect(env.layout).to receive(:remove).with :client
-            runner.events.emit :unmanage, args: :client
-          end
-
-          it 'registers for :change event' do
-            runner.register_event_hooks
-            expect(env.layout).to receive(:update).with :client
-            runner.events.emit :change, args: :client
-          end
-        end
-
-        context 'keys hooks' do
-          it 'registers for :key' do
-            env.keybinds[:f] = -> { }
-            runner.register_event_hooks
-            expect(runner.events[:key, :f]).not_to be_empty
-          end
-
-          it 'registers for :key with combined key bindings' do
-            env.keybinds[[:f, :shift]] = -> { }
-            runner.register_event_hooks
-            expect(runner.events[:key, :f, :shift]).not_to be_empty
-          end
-
-          it 'registers code evaluation with the actions handler' do
-            env.keybinds[:f] = code = proc { }
-            runner.register_event_hooks
-            expect(runner.actions).to receive(:evaluate).with code
-            runner.events.emit :key, :f
-          end
-        end
-      end
-
-      describe '#connect_manager' do
-        let(:manager)     { instance_spy Manager }
-        subject(:runner)  { described_class.new env, manager: manager }
-
-        it 'connects the manager' do
-          expect(runner.manager).to receive :connect
-          runner.connect_manager
-        end
-
-        it 'tells the manager to grab keys for env key bindings' do
-          env.keybinds[:f] = -> { }
-          expect(runner.manager).to receive(:grab_key).with :f
-          runner.connect_manager
-        end
-      end
-
-      describe '#worker' do
-        it 'returns a worker' do
-          expect(runner.worker).to respond_to :work_events
-        end
-
-        it 'setups the before_watch callback' do
-          expect(runner.manager).to receive :handle_pending_events
-          runner.worker.before_watch.call
-        end
-
-        it 'setups the read callback' do
-          expect(runner.manager).to receive :handle_pending_events
-          runner.worker.on_read.call
-        end
-
-        it 'setups the read_next callback' do
-          expect(runner.manager).to receive :handle_next_event
-          runner.worker.on_read_next.call
-        end
-
-        it 'setups the timeout callback' do
-          expect(runner.manager).to receive :flush
-          runner.worker.on_timeout.call
-        end
-      end
-
-      describe '#run_until' do
-        it 'tells the worker to watch the manager' do
-          expect(runner.worker).to receive(:watch).with runner.manager
-          runner.run_until { true }
-        end
-
-        it 'tells the worker to work events until given block is true' do
-          block = proc { }
-          allow(block).to receive(:call).and_return(false, false, false, true)
-          expect(runner.worker).to receive(:work_events).exactly(3).times
-          runner.run_until &block
-        end
-      end
-
-      describe '#terminate' do
-        it 'tells the manager to disconnect' do
-          expect(runner.manager).to receive :disconnect
-          runner.terminate
-        end
-      end
-    end
-  end
-end