uh-wm 0.0.2 → 0.0.3

data/lib/uh/wm/testing/acceptance_helpers.rb

@@ -5,6 +5,8 @@ module Uh
     module Testing
       module AcceptanceHelpers
         TIMEOUT_DEFAULT = 2
+        QUIT_KEYBINDING = 'alt+shift+q'.freeze
+        LOG_READY       = 'Working events'.freeze
 
         def uhwm_run options = '-v'
           command = %w[uhwm]
@@ -12,6 +14,14 @@ module Uh
           @interactive = @process = run command.join ' '
         end
 
+        def uhwm
+          @process
+        end
+
+        def uhwm_request_quit
+          x_key QUIT_KEYBINDING
+        end
+
         def uhwm_ensure_stop
           if @process
             x_key 'alt+shift+q'
@@ -19,32 +29,29 @@ module Uh
           end
         end
 
-        def uhwm_pid
-          @process.pid
-        end
-
-        def uhwm_output
-          @process.stdout
-        end
-
-        def uhwm_wait_output message
+        def uhwm_wait_output message, times = 1, value = nil
           output = -> { @process.stdout + @process.stderr }
           timeout_until do
             case message
-              when Regexp then output.call =~ message
-              when String then output.call.include? message
+            when Regexp then (value = output.call.scan(message)).size >= times
+            when String then output.call.include? message
             end
           end
+          value
         rescue TimeoutError => e
-          fail [
-            "expected `#{message}' not seen after #{e.timeout} seconds in:",
-            "  ```\n#{output.call.lines.map { |e| "  #{e}" }.join}  ```"
-          ].join "\n"
+          fail <<-eoh
+expected `#{message}' (#{times}) not seen after #{e.timeout} seconds in:
+  ```\n#{output.call.lines.map { |e| "  #{e}" }.join}  ```
+          eoh
+        end
+
+        def uhwm_wait_ready
+          uhwm_wait_output LOG_READY
         end
 
         def uhwm_run_wait_ready options = nil
           if options then uhwm_run options else uhwm_run end
-          uhwm_wait_output 'Connected to'
+          uhwm_wait_ready
         end
 
         def with_other_wm
@@ -58,21 +65,28 @@ module Uh
           @other_wm
         end
 
-        def x_client ident: :default
-          @x_clients ||= {}
+        def x_client ident = nil
+          ident             ||= :default
+          @x_clients        ||= {}
           @x_clients[ident] ||= XClient.new(ident)
         end
 
+        def x_clients_ensure_stop
+          @x_clients and @x_clients.any? and @x_clients.values.each &:terminate
+        end
+
         def x_focused_window_id
           Integer(`xdpyinfo`[/^focus:\s+window\s+(0x\h+)/, 1])
         end
 
         def x_input_event_masks
-          `xdpyinfo`[/current input event mask:\s+0x\h+([\w\s]+):/, 1].split(/\s+/).grep /Mask\z/
+          `xdpyinfo`[/current input event mask:\s+0x\h+([\w\s]+):/, 1]
+            .split(/\s+/)
+            .grep /Mask\z/
         end
 
-        def x_key key
-          fail "cannot simulate X key `#{key}'" unless system "xdotool key #{key}"
+        def x_key k
+          fail "cannot simulate X key `#{k}'" unless system "xdotool key #{k}"
         end
 
         def x_socket_check pid
@@ -84,41 +98,14 @@ module Uh
           end.any?
         end
 
-        def x_window_id **options
-          x_client(options).window_id
-        end
-
-        def x_window_name
-          x_client.window_name
-        end
-
-        def x_window_map times: 1, **options
-          times.times { x_client(options).map }
-          x_client(options).sync
-        end
-
-        def x_window_map_state **options
-          `xwininfo -id #{x_window_id options}`[/Map State: (\w+)/, 1]
-        end
-
-        def x_window_unmap **options
-          x_client(options).unmap
-          x_client(options).sync
-        end
-
-        def x_window_destroy **options
-          x_client(options).destroy
-          x_client(options).sync
-        end
-
-        def x_clients_ensure_stop
-          @x_clients and @x_clients.any? and @x_clients.values.each &:terminate
+        def x_window_map_state window_id
+          `xwininfo -id #{window_id}`[/Map State: (\w+)/, 1]
         end
 
 
         private
 
-        def timeout_until
+        def timeout_until message = 'condition not met after %d seconds'
           timeout = ENV.key?('UHWMTEST_TIMEOUT') ?
             ENV['UHWMTEST_TIMEOUT'].to_i :
             TIMEOUT_DEFAULT
@@ -129,7 +116,7 @@ module Uh
             end
           end
         rescue Timeout::Error
-          fail TimeoutError.new('execution expired', timeout)
+          fail TimeoutError.new(message % timeout, timeout)
         end
 
 
@@ -160,9 +147,7 @@ module Uh
           end
 
           def window
-            @window ||= @display.create_window(@geo).tap do |o|
-              o.name = @name
-            end
+            @window ||= @display.create_window(@geo).tap { |o| o.name = @name }
           end
 
           def window_id
@@ -173,7 +158,13 @@ module Uh
             @name
           end
 
-          def map
+          def window_name= name
+            @name = @window.name = name
+            window.name
+          end
+
+          def map times: 1
+            times.times { window.map }
             window.map
             self
           end

data/lib/uh/wm/version.rb

@@ -1,5 +1,5 @@
 module Uh
   module WM
-    VERSION = '0.0.2'
+    VERSION = '0.0.3'
   end
 end

data/lib/uh/wm/workers/base.rb

@@ -2,7 +2,7 @@ module Uh
   module WM
     module Workers
       class Base
-        CALLBACKS = %w[before_wait on_timeout on_read on_read_next].freeze
+        CALLBACKS = %w[before_watch on_timeout on_read on_read_next].freeze
 
         def initialize **options
           @ios = []

data/lib/uh/wm/workers/mux.rb

@@ -8,7 +8,7 @@ module Uh
         end
 
         def work_events
-          @before_wait.call if @before_wait
+          @before_watch.call if @before_watch
           if res = select(@ios, [], [], @timeout) then @on_read.call res
           else @on_timeout.call if @on_timeout end
         end

data/spec/spec_helper.rb

@@ -2,7 +2,11 @@ require 'headless'
 
 require 'uh/wm'
 
+Dir['spec/support/**/*.rb'].map { |e| require e.gsub 'spec/', '' }
+
 RSpec.configure do |config|
+  config.include Factories
+
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end

data/spec/support/factories.rb

@@ -0,0 +1,27 @@
+module Factories
+  def build_geo x = 0, y = 0, width = 640, height = 480
+    Uh::Geo.new(x, y, width, height)
+  end
+
+  def build_client window = mock_window
+    Uh::WM::Client.new(window)
+  end
+
+  def mock_event type = :xany, **options
+    double 'event', type: type, **options
+  end
+
+  def mock_event_key_press key, modifier_mask
+    mock_event :key_press,
+      key:            'f',
+      modifier_mask:  modifier_mask
+  end
+
+  def mock_window override_redirect: false
+    instance_spy Uh::Window, 'window',
+      to_s:               'wid',
+      name:               'wname',
+      wclass:             'wclass',
+      override_redirect?: override_redirect
+  end
+end

data/spec/uh/wm/actions_handler_spec.rb

@@ -6,10 +6,15 @@ module Uh
       subject(:actions) { described_class.new env, events }
 
       describe '#evaluate' do
-        it 'evaluates given code' do
+        it 'evaluates code given as Proc argument' do
           expect { actions.evaluate proc { throw :action_code } }
             .to throw_symbol :action_code
         end
+
+        it 'evaluates code given as block' do
+          expect { actions.evaluate { throw :action_code } }
+            .to throw_symbol :action_code
+        end
       end
 
       describe '#quit' do

data/spec/uh/wm/client_spec.rb

@@ -1,11 +1,8 @@
 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
+      let(:window)      { mock_window }
+      let(:geo)         { build_geo }
       subject(:client)  { described_class.new window, geo }
 
       it 'is not visible' do
@@ -33,7 +30,7 @@ module Uh
           expect(client.to_s).to include geo.to_s
         end
 
-        it 'includes window id' do
+        it 'includes window string representation' do
           expect(client.to_s).to include 'wid'
         end
       end
@@ -50,6 +47,24 @@ module Uh
         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

data/spec/uh/wm/dispatcher_spec.rb

@@ -1,7 +1,7 @@
 module Uh
   module WM
     RSpec.describe Dispatcher do
-      subject(:dispatcher)  { described_class.new }
+      subject(:dispatcher) { described_class.new }
 
       describe '#[]' do
         context 'when given key for existing hook' do

data/spec/uh/wm/env_spec.rb

@@ -70,19 +70,27 @@ module Uh
       end
 
       describe '#layout' do
-        context 'when a layout class is set' do
-          let(:some_layout) { Class.new }
+        let(:some_layout_class) { Class.new }
+
+        it 'returns the default layout' do
+          expect(env.layout).to be_an_instance_of ::Uh::Layout
+        end
 
-          before { env.layout_class = some_layout }
+        context 'when a layout is set' do
+          let(:some_layout) { some_layout_class.new }
 
-          it 'returns a new instance of this layout class' do
-            expect(env.layout).to be_an_instance_of some_layout
+          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 not set' do
-          it 'returns an instance of the default layout' do
-            expect(env.layout).to be_an_instance_of ::Uh::Layout
+        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
@@ -129,7 +137,8 @@ module Uh
 
       describe '#log_logger_level' do
         it 'logs the logger level' do
-          expect(env.logger).to receive(:info).with /log.+(warn|info|debug).+level/i
+          expect(env.logger)
+            .to receive(:info).with /log.+(warn|info|debug).+level/i
           env.log_logger_level
         end
       end

data/spec/uh/wm/manager_spec.rb

@@ -2,16 +2,13 @@ module Uh
   module WM
     RSpec.describe Manager do
       let(:block)       { proc { } }
-      let(:window)      { instance_spy Window, override_redirect?: false }
+      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 a new display' do
-        expect(manager.display).to be_a Display
-      end
-
       it 'has no clients' do
         expect(manager.clients).to be_empty
       end
@@ -111,13 +108,13 @@ module Uh
         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))
+              .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 = Geo.new(0, 0, 42, 42)
+              geo = build_geo 0, 0, 42, 42
               events.on(:configure) { geo }
               expect(window).to receive(:configure_event).with geo
               manager.configure window
@@ -126,16 +123,18 @@ module Uh
         end
 
         context 'with known window' do
-          before { manager.map window }
+          before { manager.clients << client }
 
           it 'tells the client to configure' do
-            expect(manager.clients[0]).to receive :configure
+            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])
@@ -162,40 +161,46 @@ module Uh
           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.map window }
+        before { manager.clients << client }
 
         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 }
+            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
+            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 manager.clients[0]
+            expect(block).to receive(:call).with client
             manager.unmap window
           end
         end
 
         context 'when client unmap count is strictly positive' do
-          before { manager.clients[0].unmap_count += 1 }
+          before { client.unmap_count += 1 }
 
           it 'does not unregister the client' do
-            expect { manager.unmap window }.not_to change { manager.clients }
+            manager.unmap window
+            expect(manager.clients).to include client
           end
 
           it 'decrements the unmap count' do
             manager.unmap window
-            expect(manager.clients[0].unmap_count).to eq 0
+            expect(client.unmap_count).to eq 0
           end
         end
 
@@ -215,16 +220,16 @@ module Uh
       end
 
       describe '#destroy' do
-        before { manager.map window }
+        before { manager.clients << client }
 
         it 'unregisters the client' do
-          expect { manager.destroy window }
-            .to change { manager.clients.size }.from(1).to 0
+          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 manager.clients[0]
+          expect(block).to receive(:call).with client
           manager.destroy window
         end
 
@@ -243,6 +248,30 @@ module Uh
         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'
@@ -253,7 +282,7 @@ module Uh
       end
 
       describe '#handle_pending_events' do
-        let(:event) { double 'event' }
+        let(:event) { mock_event }
 
         context 'when an event is pending on display' do
           before do
@@ -281,7 +310,7 @@ module Uh
       end
 
       describe '#handle' do
-        let(:event) { double 'event', type: :any }
+        let(:event) { mock_event }
 
         it 'emits :xevent event with the X event' do
           events.on :xevent, &block
@@ -289,13 +318,8 @@ module Uh
         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
+          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 }
@@ -313,9 +337,7 @@ module Uh
         end
 
         context 'when configure request event is given' do
-          let(:event) do
-            double 'event', type: :configure_request, window: :window
-          end
+          let(:event) { mock_event :configure_request, window: :window }
 
           it 'configures the event window' do
             expect(manager).to receive(:configure).with :window
@@ -324,7 +346,7 @@ module Uh
         end
 
         context 'when destroy_notify event is given' do
-          let(:event) { double 'event', type: :destroy_notify, window: :window }
+          let(:event) { mock_event :destroy_notify, window: :window }
 
           it 'destroy the event window' do
             expect(manager).to receive(:destroy).with :window
@@ -333,7 +355,7 @@ module Uh
         end
 
         context 'when map_request event is given' do
-          let(:event) { double 'event', type: :map_request, window: :window }
+          let(:event) { mock_event :map_request, window: :window }
 
           it 'maps the event window' do
             expect(manager).to receive(:map).with :window
@@ -342,13 +364,22 @@ module Uh
         end
 
         context 'when unmap_notify event is given' do
-          let(:event) { double 'event', type: :unmap_notify, window: :window }
+          let(:event) { mock_event :unmap_notify, window: :window }
 
-          it 'unmap the event window' do
+          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

data/spec/uh/wm/run_control_spec.rb

@@ -5,7 +5,6 @@ module Uh
     RSpec.describe RunControl do
       include FileSystemHelpers
 
-      let(:code)    { :run_control_code }
       let(:env)     { Env.new(StringIO.new) }
       subject(:rc)  { described_class.new env }
 
@@ -86,6 +85,31 @@ module Uh
         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