uh-wm 0.0.6 → 0.0.7

data/features/run_control/layout.feature

@@ -1,39 +0,0 @@
-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/run_control/modifier.feature

@@ -1,10 +0,0 @@
-Feature: `modifier' run control keyword
-
-  Scenario: configures the modifier key
-    Given a run control file with:
-      """
-      modifier :ctrl
-      """
-    And uhwm is running
-    When I press the ctrl+shift+q keys
-    Then uhwm must terminate successfully

data/features/run_control/worker.feature

@@ -1,9 +0,0 @@
-Feature: `worker' run control keyword
-
-  Scenario: configures the modifier key
-    Given a run control file with:
-      """
-      worker :mux
-      """
-    And I start uhwm
-    Then the output must match /work.+event.+mux/i

data/features/session/connection.feature

@@ -1,5 +0,0 @@
-Feature: connection to X server
-
-  Scenario: connects to X server
-    When I start uhwm
-    Then it must connect to X display

data/features/session/termination.feature

@@ -1,12 +0,0 @@
-Feature: program termination
-
-  Background:
-    Given uhwm is running
-
-  Scenario: terminates on quit request
-    When I tell uhwm to quit
-    Then uhwm must terminate successfully
-
-  Scenario: logs about termination
-    When I tell uhwm to quit
-    Then the output must match /terminat/i

data/features/steps/filesystem_steps.rb

@@ -1,3 +0,0 @@
-Given /^a file named ([^ ]+) with:$/ do |path, content|
-  write_file path, content
-end

data/features/steps/output_steps.rb

@@ -1,55 +0,0 @@
-Then /^the output must contain exactly the usage$/ do
-  assert_exact_output <<-eoh, all_output
-Usage: uhwm [options]
-
-options:
-    -v, --verbose                    enable verbose mode
-    -d, --debug                      enable debug mode
-    -f, --run-control PATH           specify alternate run control file
-    -r, --require PATH               require ruby feature
-    -l, --layout LAYOUT              specify layout
-    -w, --worker WORKER              specify worker
-
-    -h, --help                       print this message
-    -V, --version                    print version
-  eoh
-end
-
-Then /^the output must contain exactly the version$/ do
-  assert_exact_output "%s\n" % Uh::WM::VERSION, all_output
-end
-
-Then /^the output must match \/([^\/]+)\/([a-z]*)$/ do |pattern, options|
-  uhwm_wait_output Regexp.new(pattern, options)
-end
-
-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
-
-Then /^the output must contain "([^"]+)"$/ do |content|
-  uhwm_wait_output content.to_s
-end
-
-Then /^the output must contain current display$/ do
-  uhwm_wait_output ENV['DISPLAY']
-end
-
-Then /^the output must contain the window name$/ do
-  uhwm_wait_output x_window_name
-end

data/features/steps/run_control_steps.rb

@@ -1,3 +0,0 @@
-Given /^a run control file with:$/ do |content|
-  write_file '.uhwmrc.rb', content
-end

data/features/steps/run_steps.rb

@@ -1,41 +0,0 @@
-Given /^another window manager is running$/ do
-  expect(other_wm).to be_alive
-end
-
-Given /^uhwm is running$/ do
-  uhwm_run_wait_ready
-end
-
-Given /^uhwm is running with options? (-.+)$/ do |options|
-  uhwm_run_wait_ready options
-end
-
-Given /^uhwm is running with this run control file:$/ do |rc|
-  write_file '.uhwmrc.rb', rc
-  uhwm_run_wait_ready
-end
-
-When /^I start uhwm$/ do
-  uhwm_run
-end
-
-When /^I run uhwm with options? (-.+)$/ do |options|
-  uhwm_run options
-end
-
-When /^I tell uhwm to quit$/ do
-  uhwm_request_quit
-end
-
-When /^I quit uhwm$/ do
-  uhwm_request_quit
-  assert_exit_status 0
-end
-
-Then /^the exit status must be (\d+)$/ do |exit_status|
-  assert_exit_status exit_status.to_i
-end
-
-Then /^uhwm must terminate successfully$/ do
-  assert_exit_status 0
-end

data/features/steps/x_steps.rb

@@ -1,58 +0,0 @@
-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 /^I press the ([^ ]+) keys? (\d+) times$/ do |keys, times|
-  times.to_i.times { x_key keys }
-end
-
-When /^a window requests to be mapped$/ do
-  x_client.map.sync
-end
-
-When /^a window requests to be mapped (\d+) times$/ do |times|
-  x_client.map times: times.to_i
-end
-
-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_client.destroy.sync
-end
-
-When /^the window name changes to "([^"]+)"$/ do |name|
-  x_client.window_name = name
-end
-
-Then /^it must connect to X display$/ do
-  uhwm_wait_ready
-  expect(x_socket_check uhwm.pid).to be true
-end
-
-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
-  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|
-  expect(x_input_event_masks).to include mask
-end

data/features/support/env.rb

@@ -1,33 +0,0 @@
-require 'aruba/cucumber'
-require 'headless'
-
-require 'uh/wm/testing/acceptance_helpers'
-
-module Aruba
-  class SpawnProcess
-    def pid
-      @process.pid
-    end
-  end
-end
-
-World(Uh::WM::Testing::AcceptanceHelpers)
-
-Headless.new.start
-
-Before do
-  set_env 'HOME', File.expand_path(current_dir)
-end
-
-After do
-  uhwm_ensure_stop
-  x_clients_ensure_stop
-end
-
-Around '@other_wm_running' do |_, block|
-  with_other_wm { block.call }
-end
-
-if ENV.key? 'TRAVIS'
-  ENV['UHWMTEST_TIMEOUT'] = 8.to_s
-end

data/features/workers/block.feature

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

@@ -1,15 +0,0 @@
-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/spec/spec_helper.rb

@@ -1,30 +0,0 @@
-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
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.disable_monkey_patching!
-
-  config.before :all do
-    # Ensure current X display is not available from rspec test suite.
-    ENV.delete 'DISPLAY'
-  end
-
-  config.around :example, :xvfb do |example|
-    Headless.ly do
-      example.run
-    end
-  end
-end

data/spec/support/exit_helpers.rb

@@ -1,6 +0,0 @@
-module ExitHelpers
-  def trap_exit
-    yield
-  rescue SystemExit
-  end
-end

data/spec/support/factories.rb

@@ -1,27 +0,0 @@
-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/support/filesystem_helpers.rb

@@ -1,11 +0,0 @@
-require 'tempfile'
-
-module FileSystemHelpers
-  def with_file content
-    Tempfile.create('uhwm_rspec') do |f|
-      f.write content
-      f.rewind
-      yield f
-    end
-  end
-end

data/spec/uh/wm/actions_handler_spec.rb

@@ -1,35 +0,0 @@
-module Uh
-  module WM
-    RSpec.describe ActionsHandler do
-      let(:env)         { Env.new(StringIO.new) }
-      let(:events)      { Dispatcher.new }
-      subject(:actions) { described_class.new env, events }
-
-      describe '#evaluate' 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
-        it 'emits the quit event' do
-          expect(events).to receive(:emit).with :quit
-          actions.quit
-        end
-      end
-
-      describe '#layout_*' do
-        it 'delegates messages to the layout with handle_ prefix' do
-          expect(env.layout).to receive :handle_screen_sel
-          actions.layout_screen_sel :succ
-        end
-      end
-    end
-  end
-end

data/spec/uh/wm/cli_spec.rb

@@ -1,214 +0,0 @@
-require 'support/exit_helpers'
-
-module Uh
-  module WM
-    RSpec.describe CLI do
-      include ExitHelpers
-
-      let(:stdout)    { StringIO.new }
-      let(:stderr)    { StringIO.new }
-      let(:arguments) { [] }
-      subject(:cli)   { described_class.new arguments, stdout: stdout }
-
-      describe '.run' do
-        subject(:run) do
-          described_class.run arguments, stdout: stdout, stderr: stderr
-        end
-
-        # Prevent Runner from connecting a Manager and blocking.
-        before { allow(Runner).to receive :run }
-
-        it 'builds a new CLI with given arguments' do
-          expect(described_class)
-            .to receive(:new).with(arguments, stdout: stdout).and_call_original
-          run
-        end
-
-        it 'parses new CLI arguments' do
-          cli
-          allow(described_class).to receive(:new) { cli }
-          expect(cli).to receive :parse_arguments!
-          run
-        end
-
-        it 'runs new CLI' do
-          cli
-          allow(described_class).to receive(:new) { cli }
-          expect(cli).to receive :run
-          run
-        end
-
-        context 'with invalid arguments' do
-          let(:arguments) { %w[--unknown-option] }
-
-          it 'prints the usage on standard error stream' do
-            trap_exit { run }
-            expect(stderr.string).to match /\AUsage: .+/
-          end
-
-          it 'exits with a return status of 64' do
-            expect { run }.to raise_error(SystemExit) do |e|
-              expect(e.status).to eq 64
-            end
-          end
-        end
-
-        context 'when the new CLI raises a runtime error' do
-          before do
-            allow(cli).to receive(:run) { fail RuntimeError, 'some error' }
-            allow(described_class).to receive(:new) { cli }
-          end
-
-          it 'exits with a return status of 70' do
-            expect { run }.to raise_error(SystemExit) do |e|
-              expect(e.status).to eq 70
-            end
-          end
-
-          it 'formats the error' do
-            trap_exit { run }
-            expect(stderr.string)
-              .to match /\AUh::WM::RuntimeError: some error\n/
-          end
-
-          it 'does not output a backtrace' do
-            trap_exit { run }
-            expect(stderr.string).not_to include __FILE__
-          end
-
-          context 'when debug mode is enabled' do
-            let(:arguments) { %w[-d] }
-
-            it 'outputs a backtrace' do
-              trap_exit { run }
-              expect(stderr.string).to include __FILE__
-            end
-          end
-        end
-      end
-
-      describe '#initialize' do
-        it 'builds an env with given stdout' do
-          expect(cli.env.output).to be stdout
-        end
-
-        it 'syncs the output' do
-          expect(stdout).to receive(:sync=).with(true)
-          cli
-        end
-      end
-
-      describe '#run' do
-        it 'runs a runner with the env' do
-          expect(Runner).to receive(:run).with(cli.env)
-          cli.run
-        end
-      end
-
-      describe '#parse_arguments!' do
-        context 'with verbose option' do
-          let(:arguments) { %w[-v] }
-
-          it 'sets the env as verbose' do
-            cli.parse_arguments!
-            expect(cli.env).to be_verbose
-          end
-
-          it 'tells the env to log its logger level' do
-            expect(cli.env).to receive :log_logger_level
-            cli.parse_arguments!
-          end
-        end
-
-        context 'with debug option' do
-          let(:arguments) { %w[-d] }
-
-          it 'sets the env as debug' do
-            cli.parse_arguments!
-            expect(cli.env).to be_debug
-          end
-
-          it 'tells the env to log its logger level' do
-            expect(cli.env).to receive :log_logger_level
-            cli.parse_arguments!
-          end
-        end
-
-        context 'with run control option' do
-          let(:arguments) { %w[-f uhwmrc.rb] }
-
-          it 'assigns run control file path in the env' do
-            cli.parse_arguments!
-            expect(cli.env.rc_path).to eq 'uhwmrc.rb'
-          end
-        end
-
-        context 'with require option' do
-          let(:arguments) { %w[-r abbrev] }
-
-          it 'requires the given ruby feature' do
-            expect { cli.parse_arguments! }
-              .to change { $LOADED_FEATURES.grep(/abbrev/).any? }
-              .from(false).to(true)
-          end
-        end
-
-        context 'with layout option' do
-          let(:arguments) { %w[-l Object] }
-
-          it 'assigns the layout class in the env' do
-            cli.parse_arguments!
-            expect(cli.env.layout_class).to eq Object
-          end
-        end
-
-        context 'with worker option' do
-          let(:arguments) { %w[-w mux] }
-
-          it 'assigns the worker type in the env' do
-            cli.parse_arguments!
-            expect(cli.env.worker).to eq :mux
-          end
-        end
-
-        context 'with help option' do
-          let(:arguments) { %w[-h] }
-
-          it 'prints the usage banner on standard output' do
-            trap_exit { cli.parse_arguments! }
-            expect(stdout.string).to match /\AUsage: .+/
-          end
-
-          it 'prints options usage on standard output' do
-            trap_exit { cli.parse_arguments! }
-            expect(stdout.string).to match /\n^options:\n\s+-/
-          end
-        end
-
-        context 'with version option' do
-          let(:arguments) { %w[-V] }
-
-          it 'prints the version on standard output' do
-            trap_exit { cli.parse_arguments! }
-            expect(stdout.string).to eq "#{::Uh::WM::VERSION}\n"
-          end
-
-          it 'exits with a return status of 0' do
-            expect { cli.parse_arguments! }.to raise_error(SystemExit) do |e|
-              expect(e.status).to eq 0
-            end
-          end
-        end
-
-        context 'with invalid option' do
-          let(:arguments) { %w[--unknown-option] }
-
-          it 'raises a CLI::ArgumentError' do
-            expect { cli.parse_arguments! }
-              .to raise_error CLI::ArgumentError
-          end
-        end
-      end
-    end
-  end
-end