uh-wm 0.0.6 → 0.0.7

data/spec/uh/wm/client_spec.rb

@@ -1,148 +0,0 @@
-module Uh
-  module WM
-    RSpec.describe Client do
-      let(:window)      { mock_window }
-      let(:geo)         { build_geo }
-      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 string representation' 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 '#update_window_properties' do
-        it 'updates the cached window name' do
-          client.name
-          allow(window).to receive(:name) { 'new name' }
-          expect { client.update_window_properties }
-            .to change { client.name }
-            .from('wname').to 'new name'
-        end
-
-        it 'updates the cached window class' do
-          client.wclass
-          allow(window).to receive(:wclass) { 'new class' }
-          expect { client.update_window_properties }
-            .to change { client.wclass }
-            .from('wclass').to 'new class'
-        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

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

@@ -1,154 +0,0 @@
-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
-        let(:some_layout_class) { Class.new }
-
-        it 'returns the default layout' do
-          expect(env.layout).to be_an_instance_of ::Uh::Layout
-        end
-
-        context 'when a layout is set' do
-          let(:some_layout) { some_layout_class.new }
-
-          before { env.layout = some_layout }
-
-          it 'returns the assigned layout' do
-            expect(env.layout).to be some_layout
-          end
-        end
-
-        context 'when a layout class is set' do
-          before { env.layout_class = some_layout_class }
-
-          it 'returns a new instance of this layout class' do
-            expect(env.layout).to be_an_instance_of some_layout_class
-          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