fusuma-plugin-wmctrl 0.4.0.pre2 → 1.0.0

data/spec/fusuma/plugin/plugin/executors/wmctrl_executor_spec.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'fusuma/plugin/executors/executor'
+require 'fusuma/plugin/events/event'
+require 'fusuma/plugin/events/records/index_record'
+
+require './lib/fusuma/plugin/executors/wmctrl_executor'
+
+module Fusuma
+  module Plugin
+    module Executors
+      RSpec.describe WmctrlExecutor do
+        before do
+          @workspace = double(Workspace)
+          allow(Workspace)
+            .to receive(:new)
+            .and_return(@workspace)
+
+          index = Config::Index.new([:dummy, 1, :direction])
+          record = Events::Records::IndexRecord.new(index: index)
+          @event = Events::Event.new(tag: 'dummy_detector', record: record)
+          @executor = WmctrlExecutor.new
+          allow(@executor).to receive(:search_command).and_return 'dummy command'
+        end
+
+        around do |example|
+          ConfigHelper.load_config_yml = <<~CONFIG
+            dummy:
+              1:
+                direction:
+                  workspace: 'prev'
+          CONFIG
+
+          example.run
+
+          Config.custom_path = nil
+        end
+
+        describe '#execute' do
+          it 'detach' do
+            pid = rand(20)
+            allow(Process).to receive(:spawn).with(@executor.search_command(@event))
+                                             .and_return pid
+
+            expect(Process).to receive(:detach).with(pid)
+
+            @executor.execute(@event)
+          end
+        end
+
+        describe '#executable?' do
+          context 'when given valid event tagged as xxxx_detector' do
+            it { expect(@executor.executable?(@event)).to be_truthy }
+          end
+
+          context 'when given INVALID event tagged as invalid_tag' do
+            before do
+              @event.tag = 'invalid_tag'
+            end
+            it { expect(@executor.executable?(@event)).to be_falsey }
+          end
+        end
+
+        describe '#search_command' do
+          before do
+            allow(@executor).to receive(:search_command).and_call_original
+
+            @current_workspace = 1
+            @total_workspaces = 3
+            allow(@workspace)
+              .to receive(:workspace_values)
+              .and_return([@current_workspace, @total_workspaces])
+          end
+          context "when workspace: 'prev'" do
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                dummy:
+                  1:
+                    direction:
+                      workspace: 'prev'
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it 'should return wmctrl command' do
+              expect(@workspace).to receive(:move_command).with(direction: 'prev')
+              @executor.search_command(@event)
+            end
+          end
+
+          context "when window: 'prev'" do
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                dummy:
+                  1:
+                    direction:
+                      window: 'prev'
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it 'should return wmctrl command' do
+              expect(@workspace).to receive(:move_window_command).with(direction: 'prev')
+              @executor.search_command(@event)
+            end
+          end
+
+          context "when window: 'fullscreen'" do
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                dummy:
+                  1:
+                    direction:
+                      window: 'fullscreen'
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it 'should return wmctrl command' do
+              expect(@executor.search_command(@event))
+                .to match(/wmctrl -r :ACTIVE: -b toggle,fullscreen/)
+            end
+          end
+
+          context 'when window: [fullscreen: something]' do
+            context "when fullscreen: 'toggle'" do
+              around do |example|
+                ConfigHelper.load_config_yml = <<~CONFIG
+                  dummy:
+                    1:
+                      direction:
+                        window:
+                          fullscreen: 'toggle'
+                CONFIG
+
+                example.run
+
+                Config.custom_path = nil
+              end
+
+              it 'should return wmctrl command' do
+                expect(@executor.search_command(@event))
+                  .to match(/wmctrl -r :ACTIVE: -b toggle,fullscreen/)
+              end
+            end
+
+            context "when fullscreen: 'add'" do
+              around do |example|
+                ConfigHelper.load_config_yml = <<~CONFIG
+                  dummy:
+                    1:
+                      direction:
+                        window:
+                          fullscreen: 'add'
+                CONFIG
+
+                example.run
+
+                Config.custom_path = nil
+              end
+
+              it 'should return wmctrl command' do
+                expect(@executor.search_command(@event))
+                  .to match(/wmctrl -r :ACTIVE: -b add,fullscreen/)
+              end
+            end
+
+            context "when fullscreen: 'remove'" do
+              around do |example|
+                ConfigHelper.load_config_yml = <<~CONFIG
+                  dummy:
+                    1:
+                      direction:
+                        window:
+                          fullscreen: 'remove'
+                CONFIG
+
+                example.run
+
+                Config.custom_path = nil
+              end
+
+              it 'should return wmctrl command' do
+                expect(@executor.search_command(@event))
+                  .to match(/wmctrl -r :ACTIVE: -b remove,fullscreen/)
+              end
+            end
+          end
+
+          context "when window: 'maximized'" do
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                dummy:
+                  1:
+                    direction:
+                      window: 'maximized'
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it 'should return wmctrl command' do
+              expect(@executor.search_command(@event))
+                .to match(/wmctrl -r :ACTIVE: -b toggle,maximized/)
+            end
+          end
+
+          context 'when window: [maximized: something]' do
+            context "when maximized: 'toggle'" do
+              around do |example|
+                ConfigHelper.load_config_yml = <<~CONFIG
+                  dummy:
+                    1:
+                      direction:
+                        window:
+                          maximized: 'toggle'
+                CONFIG
+
+                example.run
+
+                Config.custom_path = nil
+              end
+
+              it 'should return wmctrl command' do
+                expect(@executor.search_command(@event))
+                  .to match(/wmctrl -r :ACTIVE: -b toggle,maximized/)
+              end
+            end
+
+            context "when maximized: 'add'" do
+              around do |example|
+                ConfigHelper.load_config_yml = <<~CONFIG
+                  dummy:
+                    1:
+                      direction:
+                        window:
+                          maximized: 'add'
+                CONFIG
+
+                example.run
+
+                Config.custom_path = nil
+              end
+
+              it 'should return wmctrl command' do
+                expect(@executor.search_command(@event))
+                  .to match(/wmctrl -r :ACTIVE: -b add,maximized/)
+              end
+            end
+
+            context "when maximized: 'remove'" do
+              around do |example|
+                ConfigHelper.load_config_yml = <<~CONFIG
+                  dummy:
+                    1:
+                      direction:
+                        window:
+                          maximized: 'remove'
+                CONFIG
+
+                example.run
+
+                Config.custom_path = nil
+              end
+
+              it 'should return wmctrl command' do
+                expect(@executor.search_command(@event))
+                  .to match(/wmctrl -r :ACTIVE: -b remove,maximized/)
+              end
+            end
+          end
+          context "when window: 'close'" do
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                dummy:
+                  1:
+                    direction:
+                      window: 'close'
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it 'should return wmctrl command' do
+              expect(@executor.search_command(@event))
+                .to match(/wmctrl -c :ACTIVE:/)
+            end
+          end
+
+          describe 'wrap_navigation: true' do
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                  executors:
+                    wmctrl_executor:
+                      wrap-navigation: true
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it 'should wrap-navigation mode' do
+              expect(Workspace).to receive(:new).with(
+                wrap_navigation: true,
+                matrix_col_size: nil
+              )
+              WmctrlExecutor.new
+            end
+          end
+
+          describe 'matrix-col-size' do
+            context "with matrix-col-size: '3', right" do
+              around do |example|
+                ConfigHelper.load_config_yml = <<~CONFIG
+                  dummy:
+                    1:
+                      direction:
+                        window: 'right'
+                  plugin:
+                    executors:
+                      wmctrl_executor:
+                        matrix-col-size: 3
+                CONFIG
+
+                example.run
+
+                Config.custom_path = nil
+              end
+
+              it 'should return wmctrl command with index of right(next) workspace' do
+                expect(@workspace).to receive(:move_window_command_for_matrix)
+                  .with(direction: 'right')
+                @executor.search_command(@event)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/fusuma/plugin/plugin/wmctrl/workspace_spec.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/plugin/wmctrl/workspace'
+
+module Fusuma
+  module Plugin
+    module Wmctrl
+      RSpec.describe Workspace do
+        def stub_workspace_values(current:, total:)
+          allow(@workspace).to receive(:workspace_values).and_return([current, total])
+        end
+
+        before { @workspace = Workspace.new }
+
+        describe '#move_command' do
+          before { stub_workspace_values(current: 1, total: 3) }
+
+          context "with 'direction: next'" do
+            before { @direction = 'next' }
+            it 'returns wmctrl command to move NEXT workspace' do
+              expect(@workspace.move_command(direction: @direction))
+                .to match(/wmctrl -s 2/)
+            end
+            it 'calls next_workspace_num' do
+              expect(@workspace).to receive(:next_workspace_num).with(step: 1)
+              @workspace.move_command(direction: @direction)
+            end
+          end
+        end
+
+        describe '#move_command_for_matrix' do
+          before do
+            @workspace = Workspace.new(matrix_col_size: 3)
+            stub_workspace_values(current: 0, total: 9)
+          end
+
+          context "with direction: 'right'" do
+            before { @direction = 'right' }
+
+            it 'returns wmctrl command to move RIGHT workspace' do
+              expect(@workspace.move_command_for_matrix(direction: @direction))
+                .to match(/wmctrl -s 1/)
+            end
+            it 'calls next_workspace_num_for_matrix' do
+              expect(@workspace).to receive(:next_workspace_num_for_matrix)
+                .with(direction: @direction)
+              @workspace.move_command_for_matrix(direction: @direction)
+            end
+          end
+          context "with direction: 'down'" do
+            before { @direction = 'down' }
+
+            it 'returns wmctrl command to move workspace to DOWN' do
+              expect(@workspace.move_command_for_matrix(direction: @direction))
+                .to match(/wmctrl -s 3/)
+            end
+          end
+        end
+
+        describe '#move_window_command' do
+          before { stub_workspace_values(current: 1, total: 3) }
+
+          context "with direction: 'next'" do
+            before { @direction = 'next' }
+
+            it 'returns wmctrl command to move NEXT workspace' do
+              wmctrl_move_window = /wmctrl -r :ACTIVE: -t 2/
+              wmctrl_move_workspace = /wmctrl -s 2/
+              expect(@workspace.move_window_command(direction: @direction))
+                .to match(wmctrl_move_window)
+              expect(@workspace.move_window_command(direction: @direction))
+                .to match(wmctrl_move_workspace)
+            end
+          end
+
+          context "with direction: 'prev'" do
+            before { @direction = 'prev' }
+
+            it 'returns wmctrl command to move NEXT workspace' do
+              wmctrl_move_window = /wmctrl -r :ACTIVE: -t 0/
+              wmctrl_move_workspace = /wmctrl -s 0/
+              expect(@workspace.move_window_command(direction: @direction))
+                .to match(wmctrl_move_window)
+              expect(@workspace.move_window_command(direction: @direction))
+                .to match(wmctrl_move_workspace)
+            end
+          end
+        end
+
+        describe '#move_window_command_for_matrix' do
+          before do
+            @workspace = Workspace.new(matrix_col_size: 3)
+            stub_workspace_values(current: 0, total: 9)
+          end
+
+          context "with direction: 'right'" do
+            before { @direction = 'right' }
+
+            it 'returns wmctrl command to move NEXT workspace' do
+              wmctrl_move_window = /wmctrl -r :ACTIVE: -t 1/
+              wmctrl_move_workspace = /wmctrl -s 1/
+              expect(@workspace.move_window_command_for_matrix(direction: @direction))
+                .to match(wmctrl_move_window)
+              expect(@workspace.move_window_command_for_matrix(direction: @direction))
+                .to match(wmctrl_move_workspace)
+            end
+          end
+          context "with direction: 'down'" do
+            before { @direction = 'down' }
+
+            it 'returns wmctrl command to move NEXT workspace' do
+              wmctrl_move_window = /wmctrl -r :ACTIVE: -t 3/
+              wmctrl_move_workspace = /wmctrl -s 3/
+              expect(@workspace.move_window_command_for_matrix(direction: @direction))
+                .to match(wmctrl_move_window)
+              expect(@workspace.move_window_command_for_matrix(direction: @direction))
+                .to match(wmctrl_move_workspace)
+            end
+          end
+        end
+
+        describe '#next_workspace_num' do
+          before { stub_workspace_values(current: 1, total: 3) }
+          context 'with step: 1' do
+            before { @step = 1 }
+            it { expect(@workspace.next_workspace_num(step: @step)).to eq 1 + @step }
+          end
+        end
+
+        describe '#next_workspace_num_for_matrix' do
+          context 'without matrix option' do
+            before { @workspace = Workspace.new(matrix_col_size: nil) }
+
+            it 'raises InvalidOption' do
+              expect do
+                @workspace.next_workspace_num_for_matrix(direction: 'prev')
+              end.to raise_error(Workspace::InvalidOption)
+            end
+          end
+
+          context 'with matrix_col_size: 3' do
+            # +---+---+---+
+            # | 0 | 1 | 2 |
+            # +---+---+---+
+            # | 3 | 4 | 5 |
+            # +---+---+---+
+            # | 6 | 7 | 8 |
+            # +---+---+---+
+            before do
+              @workspace = Workspace.new(matrix_col_size: 3)
+              stub_workspace_values(current: 1, total: 9)
+            end
+
+            context 'with invalid direction' do
+              before { @direction = 'foo' }
+              it 'raises InvalidOption' do
+                expect do
+                  @workspace.next_workspace_num_for_matrix(direction: @direction)
+                end.to raise_error(RuntimeError, "#{@direction} is invalid key")
+              end
+            end
+
+            context 'with direction: right' do
+              before { @direction = 'right' }
+              it 'next workspace' do
+                expect(
+                  @workspace.next_workspace_num_for_matrix(direction: @direction)
+                ).to eq 2
+              end
+              context 'when current_workspace is right edge' do
+                before { stub_workspace_values(current: 2, total: 9) }
+                it 'same workspace' do
+                  expect(
+                    @workspace.next_workspace_num_for_matrix(direction: @direction)
+                  ).to eq 2
+                end
+
+                context 'with wrap_navigation: true' do
+                  before { @workspace.instance_variable_set(:@wrap_navigation, true) }
+                  it 'same workspace' do
+                    expect(
+                      @workspace.next_workspace_num_for_matrix(direction: @direction)
+                    ).to eq 0
+                  end
+                end
+              end
+            end
+            context 'with direction: down' do
+              before { @direction = 'down' }
+              it 'next workspace' do
+                expect(
+                  @workspace.next_workspace_num_for_matrix(direction: @direction)
+                ).to eq 4
+              end
+              context 'when current_workspace is bottom' do
+                before { stub_workspace_values(current: 7, total: 9) }
+                it 'same workspace' do
+                  expect(
+                    @workspace.next_workspace_num_for_matrix(direction: @direction)
+                  ).to eq 7
+                end
+
+                context 'with wrap_navigation: true' do
+                  before { @workspace.instance_variable_set(:@wrap_navigation, true) }
+                  it 'same workspace' do
+                    expect(
+                      @workspace.next_workspace_num_for_matrix(direction: @direction)
+                    ).to eq 1
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        describe '#matrix_size' do
+          context 'with matrix_col_size' do
+            before do
+              @workspace = Workspace.new(matrix_col_size: 3)
+              stub_workspace_values(current: 1, total: 3)
+            end
+            it { expect(@workspace.matrix_size(3)).to eq [1, 3] }
+          end
+          context 'with matrix_col_size' do
+            before do
+              @workspace = Workspace.new(matrix_col_size: nil)
+              stub_workspace_values(current: 1, total: 3)
+            end
+            it { expect { @workspace.matrix_size(3) }.to raise_error Workspace::InvalidOption }
+          end
+        end
+      end
+    end
+  end
+end