uh-wm 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba8fdd593aed4b5a3c017c9dba5f2bf97e180b90
-  data.tar.gz: 1bc9621e7454e1fd4aaf1370eaee472ec35281eb
+  metadata.gz: 40e271eacf6628e4196a0a442cda080fad7e920d
+  data.tar.gz: c75d3a2df941bc52cef89ffbcc6c9268637e871a
 SHA512:
-  metadata.gz: b7a6b5b73f564fb63fcf89724307dd9a5934b9fd3210e90c6df722ed1159928638485706090e3c94d9cddb3db4578398f83efe3c997b86e4c126974b91c855ca
-  data.tar.gz: 40cbe74253fa28aa76cf0eb5cf762bd14c1fe4ddced31a4e6143fd6751bb6eac65974bc77b45f993828e109714ce34b33c304bf8096a1c5de758a992c1a3fcfa
+  metadata.gz: 07f4ee1ff8da6285d2e8d63b357feb0916c3dd3964b8552b11912b2fa6d54e383c900e1b094a39da17461bc2c2bf65b44dc5d0331021a0aac51dcb531e0ecd83
+  data.tar.gz: 38a41438342a2660ce49536008c7789402596bbd9dcbeb24335d6337f3dd7c9fe6aa3a9d2269be7bdb4714c88e9b252260489474160a485d0dd22ed69a80a963

data/README.md

@@ -1,36 +1,35 @@
 uh-wm
 =====
 
+[![Version      ][badge-version-img]][badge-version-uri]
+[![Build status ][badge-build-img]][badge-build-uri]
+[![Code Climate ][badge-cclimate-img]][badge-cclimate-uri]
+
+
   uh-wm is a minimalistic tiling and stacking window manager for X. It
 shares some similarities with dwm and wmii, but is written in ruby so
 you can configure and extend features with ruby code.
 
   The layout strategy is interchangeable, the default one being the
-`uh-layout` ruby gem. A layout is a simple object obeying a defined
-protocol.
+`uh-layout` ruby gem. A layout is a simple ruby object responding to
+specific methods.
 
-  Features:
+  Main features:
 
   * Xinerama support;
   * Multiple event handling strategy: blocking or multiplexing
-    (`select()`);
-  * Configuration with a run control file;
+    with `select()`;
+  * Configuration with a run control file (ruby DSL);
   * Key bindings with user defined code as callback;
   * Configurable modifier key;
-  * Support user-defined layout strategy;
-  * Program execution via key binding.
-
-  * No re-parenting (so no window decoration either);
-  * No grabbing of the modifier key;
+  * Support user-defined layout strategies;
+  * Program execution;
+  * No re-parenting (therefore, no window decoration either);
+  * No grabbing of the modifier key alone;
   * No mouse handling;
   * Very limited ICCCM support.
 
 
-[![Version      ][badge-version-img]][badge-version-uri]
-[![Build status ][badge-build-img]][badge-build-uri]
-[![Code Climate ][badge-cclimate-img]][badge-cclimate-uri]
-
-
 Getting started
 ---------------
 

data/features/layout/manage.feature

@@ -8,5 +8,5 @@ Feature: layout client management
     Then the window must be mapped
 
   Scenario: focuses new client window
-    When a window requests to be mapped
+    When a window is mapped
     Then the window must be focused

data/features/layout/protocol.feature

@@ -6,10 +6,26 @@ Feature: layout protocol
       class Layout
         def register display
           puts display
+          display.create_subwindow(Uh::Geo.new(0, 0, 640, 16)).tap do |o|
+            o.show
+          end
         end
 
         def << client
-          puts client
+          puts "testing_#<<_#{client.name}"
+          client.show
+        end
+
+        def remove client
+          puts "testing_#remove_#{client.name}"
+        end
+
+        def update client
+          puts "testing_#update_#{client.name}"
+        end
+
+        def expose window
+          puts "testing_#expose_#{window.id}"
         end
       end
       """
@@ -21,4 +37,20 @@ Feature: layout protocol
   Scenario: tells the layout to manage a client with #<< message
     Given uhwm is running with options -v -r./layout -l Layout
     When a window requests to be mapped
-    Then the output must contain the window name
+    Then the output must contain "testing_#<<_XClient/default"
+
+  Scenario: tells the layout to unmanage a client with #remove message
+    Given uhwm is running with options -v -r./layout -l Layout
+    And a window is mapped
+    When the window is unmapped
+    Then the output must contain "testing_#remove_XClient/default"
+
+  Scenario: tells the layout to update a changed client with #update message
+    Given uhwm is running with options -v -r./layout -l Layout
+    And a window is mapped
+    When the window name changes to "testing_new_name"
+    Then the output must contain "testing_#update_testing_new_name"
+
+  Scenario: tells the layout about an exposed window with #expose message
+    Given I run uhwm with options -r./layout -l Layout
+    Then the output must match /testing_#expose_\d+/

data/features/layout/unmanage.feature

@@ -6,5 +6,5 @@ Feature: layout client unmanagement
     And a second window is mapped
 
   Scenario: maps another window
-    When the second window requests to be unmapped
+    When the second window is unmapped
     Then the first window must be mapped

data/features/manager/change.feature

@@ -0,0 +1,7 @@
+Feature: clients window properties updating
+
+  Scenario: logs when the window properties of a client change
+    Given uhwm is running
+    And a window is mapped
+    When the window name changes to "testing_new_name"
+    Then the output must match /updat.+testing_new_name/i

data/features/manager/expose.feature

@@ -0,0 +1,5 @@
+Feature: expose events handling
+
+  Scenario: logs when an expose event is handled
+    Given uhwm is running
+    Then the output must match /expos.+window.+\d+/i

data/features/manager/unmanage.feature

@@ -2,10 +2,10 @@ Feature: manager client unmanagement
 
   Background:
     Given uhwm is running
-    And a window is managed
+    And a window is mapped
 
   Scenario: logs when a new client is unmanaged
-    When the window requests to be unmapped
+    When the window is unmapped
     Then the output must match /unmanag.+xclient/i
 
   Scenario: unmanages client on destroy notify X events

data/features/run_control/layout.feature

@@ -0,0 +1,39 @@
+Feature: `layout' run control keyword
+
+  Background:
+    Given a file named my_layout.rb with:
+      """
+      class MyLayout
+        def initialize **options
+          puts "testing_rc_layout_#{options.inspect}" if options.any?
+        end
+
+        def register *_, **options
+          puts "testing_rc_layout_register"
+        end
+      end
+      """
+
+  Scenario: configures a layout class
+    Given a run control file with:
+      """
+      layout MyLayout
+      """
+    When I run uhwm with options -r./my_layout
+    Then the output must contain "testing_rc_layout_register"
+
+  Scenario: configures a layout class with options
+    Given a run control file with:
+      """
+      layout MyLayout, foo: :bar
+      """
+    When I run uhwm with options -r./my_layout
+    Then the output must contain "testing_rc_layout_{:foo=>:bar}"
+
+  Scenario: configures a layout instance
+    Given a run control file with:
+      """
+      layout MyLayout.new
+      """
+    When I run uhwm with options -r./my_layout
+    Then the output must contain "testing_rc_layout_register"

data/features/session/termination.feature

@@ -9,5 +9,4 @@ Feature: program termination
 
   Scenario: logs about termination
     When I tell uhwm to quit
-    Then uhwm must terminate successfully
-    And the output must match /terminat/i
+    Then the output must match /terminat/i

data/features/steps/output_steps.rb

@@ -27,6 +27,17 @@ Then /^the output must not match \/([^\/]+)\/([a-z]*)$/ do |pattern, options|
   expect(all_output).not_to match Regexp.new(pattern, options)
 end
 
+Then /^the output must match \/([^\/]+)\/([a-z]*) at least (\d+) times$/ do
+    |pattern, options, times|
+  uhwm_wait_output Regexp.new(pattern, options), times.to_i
+end
+
+Then /^the output must match \/([^\/]+)\/([a-z]*) exactly (\d+) times$/ do
+    |pattern, options, times|
+  scans = uhwm_wait_output Regexp.new(pattern, options)
+  expect(scans.size).to eq times.to_i
+end
+
 Then /^the output must contain:$/ do |content|
   uhwm_wait_output content.to_s
 end

data/features/steps/run_steps.rb

@@ -24,11 +24,11 @@ When /^I run uhwm with options? (-.+)$/ do |options|
 end
 
 When /^I tell uhwm to quit$/ do
-  x_key 'alt+shift+q'
+  uhwm_request_quit
 end
 
 When /^I quit uhwm$/ do
-  x_key 'alt+shift+q'
+  uhwm_request_quit
   assert_exit_status 0
 end
 

data/features/steps/x_steps.rb

@@ -1,51 +1,56 @@
-Given /^a (\w+) window is mapped$/ do |ident|
-  x_window_map ident: ident
-end
-
-Given /^a window is managed$/ do
-  x_window_map
-  uhwm_wait_output /manag.+#{x_window_name}/i
+Given /^a(?:\s(\w+))? window is mapped$/ do |ident|
+  x_client(ident).map.sync
+  timeout_until 'window not mapped after %d seconds' do
+    x_window_map_state(x_client(ident).window_id) == 'IsViewable'
+  end
 end
 
 When /^I press the ([^ ]+) keys?$/ do |keys|
   x_key keys
 end
 
-When /^a window requests to be mapped$/ do
-  x_window_map
+When /^I press the ([^ ]+) keys? (\d+) times$/ do |keys, times|
+  times.to_i.times { x_key keys }
 end
 
-When /^the window requests to be unmapped$/ do
-  x_window_unmap
+When /^a window requests to be mapped$/ do
+  x_client.map.sync
 end
 
-When /^the (\w+) window requests to be unmapped$/ do |ident|
-  x_window_unmap ident: ident
+When /^a window requests to be mapped (\d+) times$/ do |times|
+  x_client.map times: times.to_i
 end
 
-When /^a window requests to be mapped (\d+) times$/ do |times|
-  x_window_map times: times.to_i
+When /^the(?:\s(\w+))? window is unmapped$/ do |ident|
+  x_client(ident).unmap.sync
+  timeout_until 'window not unmapped after %d seconds' do
+    x_window_map_state(x_client(ident).window_id) == 'IsUnMapped'
+  end
 end
 
 When /^the window is destroyed$/ do
-  x_window_destroy
+  x_client.destroy.sync
 end
 
-Then /^it must connect to X display$/ do
-  uhwm_wait_output 'Connected to'
-  expect(x_socket_check uhwm_pid).to be true
+When /^the window name changes to "([^"]+)"$/ do |name|
+  x_client.window_name = name
 end
 
-Then /^the window must be mapped$/ do
-  expect(x_window_map_state).to eq 'IsViewable'
+Then /^it must connect to X display$/ do
+  uhwm_wait_ready
+  expect(x_socket_check uhwm.pid).to be true
 end
 
-Then /^the (\w+) window must be mapped$/ do |ident|
-  expect(x_window_map_state ident: ident).to eq 'IsViewable'
+Then /^the(?:\s(\w+))? window must be mapped$/ do |ident|
+  timeout_until 'window not mapped after %d seconds' do
+    x_window_map_state(x_client(ident).window_id) == 'IsViewable'
+  end
 end
 
 Then /^the window must be focused$/ do
-  expect(x_focused_window_id).to eq x_window_id
+  timeout_until 'window not focused after %d seconds' do
+    x_focused_window_id == x_client.window_id
+  end
 end
 
 Then /^the input event mask must include (.+)$/ do |mask|

data/features/workers/block.feature

@@ -0,0 +1,15 @@
+Feature: blocking worker
+
+  Scenario: processes initial events
+    Given uhwm is running with options -d -w block
+    Then the output must match /xevent/i at least 2 times
+
+  Scenario: processes generated events
+    Given a run control file with:
+      """
+      key(:f) { puts 'testing_worker_read' }
+      """
+    And uhwm is running with options -d -w block
+    When I press the alt+f key 3 times
+    And I quit uhwm
+    Then the output must match /(testing_worker_read)/ exactly 3 times

data/features/workers/mux.feature

@@ -0,0 +1,15 @@
+Feature: multiplexing worker
+
+  Scenario: processes initial events
+    Given uhwm is running with options -d -w mux
+    Then the output must match /xevent/i at least 2 times
+
+  Scenario: processes generated events
+    Given a run control file with:
+      """
+      key(:f) { puts 'testing_worker_read' }
+      """
+    And uhwm is running with options -d -w mux
+    When I press the alt+f key 3 times
+    And I quit uhwm
+    Then the output must match /(testing_worker_read)/ exactly 3 times

data/lib/uh/wm/actions_handler.rb

@@ -10,8 +10,12 @@ module Uh
         @env, @events = env, events
       end
 
-      def evaluate code
-        instance_eval &code
+      def evaluate code = nil, &block
+        if code
+          instance_exec &code
+        else
+          instance_exec &block
+        end
       end
 
       def quit

data/lib/uh/wm/client.rb

@@ -31,6 +31,11 @@ module Uh
         @wclass ||= @window.wclass
       end
 
+      def update_window_properties
+        @wname  = @window.name
+        @wclass = @window.wclass
+      end
+
       def configure
         @window.configure @geo
         self

data/lib/uh/wm/env.rb

@@ -21,8 +21,8 @@ module Uh
       def_delegators  :@output, :print, :puts
 
       attr_reader   :output, :keybinds
-      attr_accessor :verbose, :debug, :rc_path, :layout_class, :modifier,
-                    :worker
+      attr_accessor :verbose, :debug, :rc_path, :modifier, :worker,
+                    :layout, :layout_class
 
       def initialize output
         @output   = output

data/lib/uh/wm/manager.rb

@@ -59,6 +59,7 @@ module Uh
         return if window.override_redirect? || client_for(window)
         @clients << client = Client.new(window)
         @events.emit :manage, args: client
+        @display.listen_events window, Events::PROPERTY_CHANGE_MASK
       end
 
       def unmap window
@@ -66,15 +67,19 @@ module Uh
         if client.unmap_count > 0
           client.unmap_count -= 1
         else
-          @clients.delete client
-          @events.emit :unmanage, args: client
+          unmanage client
         end
       end
 
       def destroy window
         return unless client = client_for(window)
-        @clients.delete client
-        @events.emit :unmanage, args: client
+        unmanage client
+      end
+
+      def update_properties window
+        return unless client = client_for(window)
+        client.update_window_properties
+        @events.emit :change, args: client
       end
 
       def handle_next_event
@@ -113,10 +118,18 @@ module Uh
         destroy event.window
       end
 
+      def handle_expose event
+        @events.emit :expose, args: event.window
+      end
+
       def handle_map_request event
         map event.window
       end
 
+      def handle_property_notify event
+        update_properties event.window
+      end
+
       def handle_unmap_notify event
         unmap event.window
       end
@@ -125,6 +138,11 @@ module Uh
         @clients.find { |e| e.window == window }
       end
 
+      def unmanage client
+        @clients.delete client
+        @events.emit :unmanage, args: client
+      end
+
       def check_other_wm!
         Display.on_error { fail OtherWMRunningError }
         @display.listen_events INPUT_MASK

data/lib/uh/wm/run_control.rb

@@ -32,6 +32,18 @@ module Uh
         @env.keybinds[translate_keysym *keysyms] = block
       end
 
+      def layout arg, **options
+        if arg.is_a? Class
+          if options.any?
+            @env.layout = arg.new options
+          else
+            @env.layout_class = arg
+          end
+        else
+          @env.layout = arg
+        end
+      end
+
       def worker type, **options
         @env.worker = [type, options]
       end

data/lib/uh/wm/runner.rb

@@ -51,19 +51,14 @@ module Uh
 
       def connect_manager
         manager.connect
-        @env.keybinds.each do |keysym, _|
-          manager.grab_key *keysym
-        end
+        @env.keybinds.each { |keysym, _| manager.grab_key *keysym }
       end
 
       def worker
         @worker ||= Workers.build(*(@env.worker)).tap do |w|
-          w.on_read do
-            @manager.handle_pending_events
-          end
-          w.on_read_next do
-            @manager.handle_next_event
-          end
+          w.before_watch  { @manager.handle_pending_events }
+          w.on_read       { @manager.handle_pending_events }
+          w.on_read_next  { @manager.handle_next_event }
           w.on_timeout do |*args|
             log_debug "Worker timeout: #{args.inspect}"
             log_debug 'Flushing X output buffer'
@@ -119,6 +114,14 @@ module Uh
           log "Unmanaging client #{client}"
           layout.remove client
         end
+        @events.on :change do |client|
+          log "Updating client #{client}"
+          layout.update client
+        end
+        @events.on :expose do |window|
+          log "Exposing window: #{window}"
+          layout.expose window
+        end
       end
 
       def register_keybinds_hooks