fusuma-plugin-wmctrl 0.4.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8654418db5d6e428e786f5d8632ba00a302a2a4fc9cc78c89cbcdaca5dd12a2
-  data.tar.gz: d12bb4124ad144c82e3c30302d60a64261e7f612e783a6cb26e50ded61f90d51
+  metadata.gz: 5143de56caec58bc113092172aab1b6ad257e245376ff43633fa994adc77a5d8
+  data.tar.gz: 9956dd5820be73525c539a6c1dc67435b4562a8bd116cd05d98db22608189518
 SHA512:
-  metadata.gz: 902bfc1063f1a23f5a0ad03420998ef7e04b51f0e5e9f31dc1c7674d9f676ec40741311d8442642639a834ec421766d5b47b57ab206ca140470348339692eb51
-  data.tar.gz: 931711256a8f0a853f35352b018dab803f4fe5cc81637e5796a2d0c5ba30b7274680835d2a026cacef4c2d39db4e174065d7c9f6b526301385b449d1be7ebaac
+  metadata.gz: fa40be6a49d1d002916280d2b41d0943cca6f555390f5d9a4dd53821a01ebc2d70984aef90b3546d4fcbe835e613c8b8913ddaeb1f59f4674a078003692e4737
+  data.tar.gz: c5d5f213771f20985d2fbffd8ad4d269b3b095abfe6f1ecc874281fc47657f3aabf778155bd2cfb6035db031ccefc9d0b421f47261607f87068ec7afc159d1f7

data/README.md

@@ -29,7 +29,7 @@ sudo pacman -S wmctrl
 This plugin requires [Fusuma](https://github.com/iberianpig/fusuma#update) version 1.0 or later.
 
 
-**Note For Arch Based Distros:** By default in Arch Linux, when running ```gem```, gems are installed per-user (into ```~/.gem/ruby/```), instead of system-wide (into ```/usr/lib/ruby/gems/```). This is considered the best way to manage gems on Arch, because otherwise they might interfere with gems installed by Pacman. (From Arch Wiki)
+**Note For Arch Based Distros:** By default in Arch Linux, when running `gem`, gems are installed per-user (into `~/.gem/ruby/`), instead of system-wide (into `/usr/lib/ruby/gems/`). This is considered the best way to manage gems on Arch, because otherwise they might interfere with gems installed by Pacman. (From Arch Wiki)
 
 To install gems system-wide, see any of the methods listed on [Arch Wiki](https://wiki.archlinux.org/index.php/ruby#Installing_gems_system-wide)
 
@@ -46,6 +46,7 @@ Values following are available for `workspace`.
 
   * `prev` is value to switch current workspace to previous workspace.
   * `next` is value to switch current workspace to next workspace.
+  * [**[For grid-style workspaces only](#support-grid-style-workspace)**] `up` / `down` / `left` / `right` navigate to the workspace in the direction.
 
 ### `window:` property
 Add `window:` property in `~/.config/fusuma/config.yml`.
@@ -54,6 +55,7 @@ Values following are available for `window`.
 
   * `prev` is value to move active window to previous workspace.
   * `next` is value to move active window to next workspace.
+  * [**[For grid-style workspaces only](#support-grid-style-workspace)**] `up` / `down` / `left` / `right` move window to the workspace in the direction.
   * `fullscreen` is value to toggle fullscreen
     * `fullscreen: toggle` toggles the active window to fullscreen.
       ```yml
@@ -111,6 +113,8 @@ swipe:
 
 ## Configuration
 
+### Wrap navigation
+
 The plugin allows to enable (disabled by default) circular navigation between workspaces. To enable it set the following in your config file `~/.config/fusuma/config.yml`.
 
 ```yaml
@@ -120,6 +124,56 @@ plugin:
       wrap-navigation: true
 ```
 
+### Support grid-style workspace
+
+For grid-style workspace users, Fusuma has an option to move workspace up, down, left or right.
+To enable this option, set `matrix-col-size`.
+
+For example, for a 3x2 workspace, set `matrix-col-size: 3` to wmctrl_executor option.
+```yaml
+plugin:
+  executors:
+    wmctrl_executor:
+      matrix-col-size: 3
+```
+
+With this setting, the `up`/`down`/`left`/`right` properties will be enabled on `workspace:` and `window:`.
+
+#### Example
+
+```yaml
+swipe:
+  4:
+    up:
+      workspace: down
+      keypress:
+        LEFTSHIFT:
+          window: down
+    down:
+      workspace: up
+      keypress:
+        LEFTSHIFT:
+          window: up
+    left:
+      workspace: right
+      keypress:
+        LEFTSHIFT:
+          window: right
+    right:
+      workspace: left
+      keypress:
+        LEFTSHIFT:
+          window: left
+
+plugin:
+  executors:
+    wmctrl_executor:
+      matrix-col-size: 3
+```
+
+NOTE: `keypress:` property is enabled with fusuma-plugin-keypress
+https://github.com/iberianpig/fusuma-plugin-keypress
+
 
 ## Contributing
 

data/exe/fusuma-wmctrl

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require_relative '../lib/fusuma/plugin/wmctrl/window.rb'
+require_relative '../lib/fusuma/plugin/wmctrl/workspace.rb'
+require_relative '../lib/fusuma/plugin/wmctrl/version.rb'
+
+option = {}
+opt = OptionParser.new
+
+opt.on('--wrap-navigation',
+       'circular navigation between workspaces') do |v|
+  option[:wrap_navigation] = v
+end
+
+opt.on('--matrix-col-size=3',
+       'For grid-style workspace, move up, down, left or right.'
+      ) do |v|
+  option[:matrix_col_size] = v.to_i
+end
+
+opt.on('--workspace=prev|next|up|down|left|right',
+       'move workspace') do |v|
+  option[:workspace] = v
+end
+
+opt.on('--window=prev|next|up|down|left|right',
+       'move window') do |v|
+  option[:window] = v
+end
+
+opt.on('--version', 'Show version') do |v|
+  option[:version] = v
+end
+
+opt.parse!(ARGV)
+
+if option[:workspace]
+  workspace = Fusuma::Plugin::Wmctrl::Workspace.new(
+    wrap_navigation: option[:wrap_navigation], matrix_col_size: option[:matrix_col_size]
+  )
+
+  command = case property = option[:workspace]
+  when 'prev', 'next'
+    workspace.move_command(direction: property)
+  when 'left', 'right', 'up', 'down'
+    workspace.move_command_for_matrix(direction: property)
+  else
+    raise "#{property} is invalid key"
+  end
+  `#{command}`
+
+  return
+end
+
+if option[:window]
+  workspace = Fusuma::Plugin::Wmctrl::Workspace.new(
+    wrap_navigation: option[:wrap_navigation], matrix_col_size: option[:matrix_col_size]
+  )
+  window = Fusuma::Plugin::Wmctrl::Window.new
+
+  command = case property = option[:window]
+            when 'prev', 'next'
+              workspace.move_window_command(direction: property)
+            when 'left', 'right', 'up', 'down'
+              workspace.move_window_command_for_matrix(direction: property)
+            when 'maximized'
+              window.maximized(method: 'toggle')
+            when 'close'
+              window.close
+            when 'fullscreen'
+              window.fullscreen(method: 'toggle')
+            else
+              raise "#{property} is invalid key"
+            end
+
+  `#{command}`
+
+  return
+end
+
+if option[:version]
+  puts Fusuma::Plugin::Wmctrl::VERSION
+  return
+end
+
+param = ARGV.first
+
+if param.nil?
+  warn 'fusuma-wmctrl require aruguments'
+  exit 1
+end

data/fusuma-plugin-wmctrl.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '>= 2.3' # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
-  spec.add_dependency 'fusuma', '~> 2.0.0'
+  spec.required_ruby_version = '>= 2.5.1' # https://packages.ubuntu.com/search?keywords=ruby&searchon=names&exact=1&suite=all&section=main
+  # support bionic (18.04LTS) 2.5.1
+  spec.add_dependency 'fusuma', '~> 2.0'
 end

data/lib/fusuma/plugin/executors/wmctrl_executor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'posix/spawn'
-require 'singleton'
+require_relative '../wmctrl/window'
+require_relative '../wmctrl/workspace'
 
 module Fusuma
   module Plugin
@@ -16,13 +16,18 @@ module Fusuma
 
         def config_param_types
           {
-            'wrap-navigation': [TrueClass, FalseClass]
+            'wrap-navigation': [TrueClass, FalseClass],
+            'matrix-col-size': [Integer]
           }
         end
 
         def initialize
           super()
-          Workspace.configure(wrap_navigation: config_params(:'wrap-navigation'))
+          @workspace = Wmctrl::Workspace.new(
+            wrap_navigation: config_params(:'wrap-navigation'),
+            matrix_col_size: config_params(:'matrix-col-size')
+          )
+          @window = Wmctrl::Window.new
         end
 
         # execute wmctrl command
@@ -32,7 +37,7 @@ module Fusuma
           return if search_command(event).nil?
 
           MultiLogger.info(wmctrl: search_command(event))
-          pid = POSIX::Spawn.spawn(search_command(event))
+          pid = Process.spawn(search_command(event))
           Process.detach(pid)
         end
 
@@ -50,6 +55,9 @@ module Fusuma
         # @return [NilClass]
         def search_command(event)
           search_workspace_command(event) || search_window_command(event)
+        rescue Workspace::InvalidOption => e
+          MultiLogger.error(e.message)
+          exit 1
         end
 
         private
@@ -60,10 +68,16 @@ module Fusuma
         def search_workspace_command(event)
           index = Config::Index.new([*event.record.index.keys, :workspace])
 
-          direction = Config.search(index)
-          return unless direction.is_a?(String)
-
-          Workspace.move_command(direction: direction)
+          case property = Config.search(index)
+          when 'prev', 'next'
+            @workspace.move_command(direction: property)
+          when 'left', 'right', 'up', 'down'
+            @workspace.move_command_for_matrix(direction: property)
+          when nil
+            nil
+          else
+            raise "#{property} is invalid key"
+          end
         end
 
         # @param event [Event]
@@ -74,113 +88,25 @@ module Fusuma
 
           case property = Config.search(index)
           when 'prev', 'next'
-            Window.move_command(direction: property)
+            @workspace.move_window_command(direction: property)
+          when 'left', 'right', 'up', 'down'
+            @workspace.move_window_command_for_matrix(direction: property)
           when 'fullscreen'
-            Window.fullscreen(method: 'toggle')
+            @window.fullscreen(method: 'toggle')
           when 'maximized'
-            Window.maximized(method: 'toggle')
+            @window.maximized(method: 'toggle')
           when 'close'
-            Window.close
+            @window.close
           when Hash
             if property[:fullscreen]
-              Window.fullscreen(method: property[:fullscreen])
+              @window.fullscreen(method: property[:fullscreen])
             elsif property[:maximized]
-              Window.maximized(method: property[:maximized])
-            end
-          end
-        end
-
-        # Manage workspace
-        class Workspace
-          include Singleton
-
-          attr_accessor :wrap_navigation
-
-          class << self
-            # configure properties of the workspace switcher
-            # @return [NilClass]
-            def configure(wrap_navigation:)
-              instance.wrap_navigation = wrap_navigation
-            end
-
-            # get next workspace number
-            # @return [Integer]
-            def next_workspace_num(step:)
-              current_workspace_num, total_workspace_num = workspace_values
-
-              next_workspace_num = current_workspace_num + step
-
-              return next_workspace_num unless instance.wrap_navigation
-
-              if next_workspace_num.negative?
-                next_workspace_num = total_workspace_num - 1
-              elsif next_workspace_num >= total_workspace_num
-                next_workspace_num = 0
-              else
-                next_workspace_num
-              end
-            end
-
-            def move_command(direction:)
-              workspace_num = case direction
-                              when 'next'
-                                next_workspace_num(step: 1)
-                              when 'prev'
-                                next_workspace_num(step: -1)
-                              else
-                                raise "#{direction} is invalid key"
-                              end
-              "wmctrl -s #{workspace_num}"
-            end
-
-            private
-
-            # get current workspace and total workspace numbers
-            # @return [Integer, Integer]
-            def workspace_values
-              wmctrl_output = `wmctrl -d`.split("\n")
-
-              current_line = wmctrl_output.grep(/\*/).first
-              # NOTE: stderror when failed to get desktop
-              # `Cannot get current desktop properties. (_NET_CURRENT_DESKTOP or _WIN_WORKSPACE property)`
-              return [0, 1] if current_line.nil?
-
-              current_workspace_num = current_line.chars.first.to_i
-              total_workspace_num = wmctrl_output.length
-
-              [current_workspace_num, total_workspace_num]
-            end
-          end
-        end
-
-        # Manage Window
-        class Window
-          class << self
-            # @param method [String] "toggle" or "add" or "remove"
-            def maximized(method:)
-              "wmctrl -r :ACTIVE: -b #{method},maximized_vert,maximized_horz"
-            end
-
-            def close
-              'wmctrl -c :ACTIVE:'
-            end
-
-            # @param method [String] "toggle" or "add" or "remove"
-            def fullscreen(method:)
-              "wmctrl -r :ACTIVE: -b #{method},fullscreen"
-            end
-
-            def move_command(direction:)
-              workspace_num = case direction
-                              when 'next'
-                                Workspace.next_workspace_num(step: 1)
-                              when 'prev'
-                                Workspace.next_workspace_num(step: -1)
-                              else
-                                raise "#{direction} is invalid key"
-                              end
-              "wmctrl -r :ACTIVE: -t #{workspace_num} ; wmctrl -s #{workspace_num}"
+              @window.maximized(method: property[:maximized])
             end
+          when nil
+            nil
+          else
+            raise "#{property} is invalid key"
           end
         end
       end

data/lib/fusuma/plugin/wmctrl/version.rb

@@ -3,7 +3,7 @@
 module Fusuma
   module Plugin
     module Wmctrl
-      VERSION = '0.4.2'
+      VERSION = '1.1.0'
     end
   end
 end

data/lib/fusuma/plugin/wmctrl/window.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Wmctrl
+      # Manage Window
+      class Window
+        # @param method [String] "toggle" or "add" or "remove"
+        def maximized(method:)
+          "wmctrl -r :ACTIVE: -b #{method},maximized_vert,maximized_horz"
+        end
+
+        def close
+          'wmctrl -c :ACTIVE:'
+        end
+
+        # @param method [String] "toggle" or "add" or "remove"
+        def fullscreen(method:)
+          "wmctrl -r :ACTIVE: -b #{method},fullscreen"
+        end
+      end
+    end
+  end
+end

data/lib/fusuma/plugin/wmctrl/workspace.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Fusuma
+  module Plugin
+    module Wmctrl
+      # Manage workspace
+      class Workspace
+        class MissingMatrixOption < StandardError; end
+
+        def initialize(wrap_navigation: nil, matrix_col_size: nil)
+          @wrap_navigation = wrap_navigation
+          @matrix_col_size = matrix_col_size
+        end
+
+        # get next workspace number
+        # @return [Integer]
+        def next_workspace_num(step:)
+          current_workspace_num, total_workspace_num = workspace_values
+
+          next_workspace_num = current_workspace_num + step
+
+          return next_workspace_num unless @wrap_navigation
+
+          if next_workspace_num.negative?
+            next_workspace_num = total_workspace_num - 1
+          elsif next_workspace_num >= total_workspace_num
+            next_workspace_num = 0
+          else
+            next_workspace_num
+          end
+          next_workspace_num
+        end
+
+        # @return [Array<Integer>]
+        def matrix_size(total_workspace_num)
+          must_have_matrix_option!
+          col_size = @matrix_col_size
+          row_size = (total_workspace_num / col_size)
+          [row_size.to_i, col_size.to_i]
+        end
+
+        def must_have_matrix_option!
+          return if @matrix_col_size
+
+          # FIXME: move to executor
+          warn(<<~ERRRORMESSAGE)
+            Please set matrix-col-size to config.yml
+
+            ```config.yaml
+            plugin:
+              executors:
+                wmctrl_executor:
+                  matrix-col-size: 2
+            ```
+          ERRRORMESSAGE
+          raise MissingMatrixOption, 'You need to set matrix option to config.yml'
+        end
+
+        # @return [Integer]
+        # @raise RuntimeError
+        def next_workspace_num_for_matrix(direction:)
+          must_have_matrix_option!
+          current_workspace_num, total_workspace_num = workspace_values
+          row_size, col_size = matrix_size(total_workspace_num)
+          x = current_workspace_num % col_size
+          y = current_workspace_num / col_size
+          case direction
+          when 'right'
+            if x < col_size - 1
+              current_workspace_num + 1
+            elsif @wrap_navigation
+              current_workspace_num - (col_size - 1)
+            else
+              current_workspace_num
+            end
+          when 'left'
+            if x.positive?
+              current_workspace_num - 1
+            elsif @wrap_navigation
+              current_workspace_num + (col_size - 1)
+            else
+              current_workspace_num
+            end
+          when 'down'
+            if y < row_size - 1
+              current_workspace_num + col_size
+            elsif @wrap_navigation
+              (current_workspace_num + col_size) - total_workspace_num
+            else
+              current_workspace_num
+            end
+          when 'up'
+            if y.positive?
+              current_workspace_num - col_size
+            elsif @wrap_navigation
+              total_workspace_num + (current_workspace_num - col_size)
+            else
+              current_workspace_num
+            end
+          else
+            raise "#{direction} is invalid key"
+          end
+        end
+
+        def move_command(direction:)
+          workspace_num = case direction
+                          when 'next'
+                            next_workspace_num(step: 1)
+                          when 'prev'
+                            next_workspace_num(step: -1)
+                          else
+                            raise "#{direction} is invalid key"
+                          end
+          "wmctrl -s #{workspace_num}"
+        end
+
+        def move_command_for_matrix(direction:)
+          workspace_num = next_workspace_num_for_matrix(direction: direction)
+          "wmctrl -s #{workspace_num}"
+        end
+
+        def move_window_command(direction:)
+          workspace_num = case direction
+                          when 'next'
+                            next_workspace_num(step: 1)
+                          when 'prev'
+                            next_workspace_num(step: -1)
+                          else
+                            raise "#{direction} is invalid key"
+                          end
+          "wmctrl -r :ACTIVE: -t #{workspace_num} ; wmctrl -s #{workspace_num}"
+        end
+
+        def move_window_command_for_matrix(direction:)
+          workspace_num = next_workspace_num_for_matrix(direction: direction)
+          "wmctrl -r :ACTIVE: -t #{workspace_num} ; wmctrl -s #{workspace_num}"
+        end
+
+        private
+
+        # get current workspace and total workspace numbers
+        # @return [Integer, Integer]
+        def workspace_values
+          wmctrl_output = `wmctrl -d`.split("\n")
+
+          current_line = wmctrl_output.grep(/\*/).first
+          # NOTE: stderror when failed to get desktop
+          # `Cannot get current desktop properties. \
+          # (_NET_CURRENT_DESKTOP or _WIN_WORKSPACE property)`
+          return [0, 1] if current_line.nil?
+
+          current_workspace_num = current_line.chars.first.to_i
+          total_workspace_num = wmctrl_output.length
+
+          [current_workspace_num, total_workspace_num]
+        end
+      end
+    end
+  end
+end

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

@@ -13,15 +13,16 @@ module Fusuma
     module Executors
       RSpec.describe WmctrlExecutor do
         before do
+          @workspace = double(Wmctrl::Workspace)
+          allow(Wmctrl::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
-
-          @default_workspace_num = 1
-          allow(WmctrlExecutor::Workspace)
-            .to receive(:workspace_values)
-            .and_return(@default_workspace_num)
+          allow(@executor).to receive(:search_command).and_return 'dummy command'
         end
 
         around do |example|
@@ -40,9 +41,8 @@ module Fusuma
         describe '#execute' do
           it 'detach' do
             pid = rand(20)
-            allow(POSIX::Spawn)
-              .to receive(:spawn).with(@executor.search_command(@event))
-                                 .and_return pid
+            allow(Process).to receive(:spawn).with(@executor.search_command(@event))
+                                             .and_return pid
 
             expect(Process).to receive(:detach).with(pid)
 
@@ -64,6 +64,15 @@ module Fusuma
         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
@@ -79,28 +88,8 @@ module Fusuma
             end
 
             it 'should return wmctrl command' do
-              expect(@executor.search_command(@event))
-                .to match(/wmctrl -s #{@default_workspace_num - 1}/)
-            end
-          end
-
-          context "when workspace: 'next'" do
-            around do |example|
-              ConfigHelper.load_config_yml = <<~CONFIG
-                dummy:
-                  1:
-                    direction:
-                      workspace: 'next'
-              CONFIG
-
-              example.run
-
-              Config.custom_path = nil
-            end
-
-            it 'should return wmctrl command' do
-              expect(@executor.search_command(@event))
-                .to match(/wmctrl -s #{@default_workspace_num + 1}/)
+              expect(@workspace).to receive(:move_command).with(direction: 'prev')
+              @executor.search_command(@event)
             end
           end
 
@@ -119,32 +108,8 @@ module Fusuma
             end
 
             it 'should return wmctrl command' do
-              expect(@executor.search_command(@event))
-                .to match(/wmctrl -r :ACTIVE: -t #{@default_workspace_num - 1}/)
-              expect(@executor.search_command(@event))
-                .to match(/wmctrl -s #{@default_workspace_num - 1}/)
-            end
-          end
-
-          context "when window: 'next'" do
-            around do |example|
-              ConfigHelper.load_config_yml = <<~CONFIG
-                dummy:
-                  1:
-                    direction:
-                      window: 'next'
-              CONFIG
-
-              example.run
-
-              Config.custom_path = nil
-            end
-
-            it 'should return wmctrl command' do
-              expect(@executor.search_command(@event))
-                .to match(/wmctrl -r :ACTIVE: -t #{@default_workspace_num + 1}/)
-              expect(@executor.search_command(@event))
-                .to match(/wmctrl -s #{@default_workspace_num + 1}/)
+              expect(@workspace).to receive(:move_window_command).with(direction: 'prev')
+              @executor.search_command(@event)
             end
           end
 
@@ -338,112 +303,40 @@ module Fusuma
           end
 
           describe 'wrap_navigation: true' do
-            context "when workspace: 'prev' and current workspace 0" do
-              around do |example|
-                ConfigHelper.load_config_yml = <<~CONFIG
-                  dummy:
-                    1:
-                      direction:
-                        workspace: 'prev'
-                  plugin:
-                    executors:
-                      wmctrl_executor:
-                        wrap-navigation: true
-                CONFIG
-
-                example.run
-
-                Config.custom_path = nil
-              end
-
-              it 'should return wmctrl command with an index last workspace' do
-                current_workspace = 0
-                total_workspaces = 3
-
-                allow(WmctrlExecutor::Workspace)
-                  .to receive(:workspace_values)
-                  .and_return([current_workspace, total_workspaces])
-
-                expect(@executor.search_command(@event))
-                  .to match(/wmctrl -s #{total_workspaces - 1}/)
-              end
-            end
-
-            context "when workspace: 'next' and current workspace = total - 1" do
-              around do |example|
-                ConfigHelper.load_config_yml = <<~CONFIG
-                  dummy:
-                    1:
-                      direction:
-                        workspace: 'next'
-                  plugin:
-                    executors:
-                      wmctrl_executor:
-                        wrap-navigation: true
-                CONFIG
-
-                example.run
-
-                Config.custom_path = nil
-              end
-
-              it 'should return wmctrl command with an index of first workspace' do
-                current_workspace = 3
-                total_workspaces = 4
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                  executors:
+                    wmctrl_executor:
+                      wrap-navigation: true
+              CONFIG
 
-                allow(WmctrlExecutor::Workspace)
-                  .to receive(:workspace_values)
-                  .and_return([current_workspace, total_workspaces])
+              example.run
 
-                expect(@executor.search_command(@event))
-                  .to match(/wmctrl -s 0/)
-              end
+              Config.custom_path = nil
             end
 
-            context "when window: 'prev' and current workspace has index 0" do
-              around do |example|
-                ConfigHelper.load_config_yml = <<~CONFIG
-                  dummy:
-                    1:
-                      direction:
-                        window: 'prev'
-                  plugin:
-                    executors:
-                      wmctrl_executor:
-                        wrap-navigation: true
-                CONFIG
-
-                example.run
-
-                Config.custom_path = nil
-              end
-
-              it 'should return wmctrl command with index of last workspace' do
-                current_workspace = 0
-                total_workspaces = 5
-
-                allow(WmctrlExecutor::Workspace)
-                  .to receive(:workspace_values)
-                  .and_return([current_workspace, total_workspaces])
-
-                expect(@executor.search_command(@event))
-                  .to match(/wmctrl -r :ACTIVE: -t #{total_workspaces - 1}/)
-                expect(@executor.search_command(@event))
-                  .to match(/wmctrl -s #{total_workspaces - 1}/)
-              end
+            it 'should wrap-navigation mode' do
+              expect(Wmctrl::Workspace).to receive(:new).with(
+                wrap_navigation: true,
+                matrix_col_size: nil
+              )
+              WmctrlExecutor.new
             end
+          end
 
-            context "when window: 'next' and current workspace is last" do
+          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: 'next'
+                        window: 'right'
                   plugin:
                     executors:
                       wmctrl_executor:
-                        wrap-navigation: true
+                        matrix-col-size: 3
                 CONFIG
 
                 example.run
@@ -451,18 +344,10 @@ module Fusuma
                 Config.custom_path = nil
               end
 
-              it 'should return wmctrl command with index of first workspace' do
-                current_workspace = 4
-                total_workspaces = 5
-
-                allow(WmctrlExecutor::Workspace)
-                  .to receive(:workspace_values)
-                  .and_return([current_workspace, total_workspaces])
-
-                expect(@executor.search_command(@event))
-                  .to match(/wmctrl -r :ACTIVE: -t 0/)
-                expect(@executor.search_command(@event))
-                  .to match(/wmctrl -s 0/)
+              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

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(Wmctrl::Workspace::MissingMatrixOption)
+            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::MissingMatrixOption }
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma-plugin-wmctrl
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 1.1.0
 platform: ruby
 authors:
 - iberianpig
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-19 00:00:00.000000000 Z
+date: 2021-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fusuma
@@ -16,18 +16,19 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '2.0'
 description: fusuma-plugin-wmctrl is Fusuma plugin for window manager.
 email:
 - yhkyky@gmail.com
-executables: []
+executables:
+- fusuma-wmctrl
 extensions: []
 extra_rdoc_files: []
 files:
@@ -35,11 +36,15 @@ files:
 - README.md
 - bin/console
 - bin/setup
+- exe/fusuma-wmctrl
 - fusuma-plugin-wmctrl.gemspec
 - lib/fusuma/plugin/executors/wmctrl_executor.rb
 - lib/fusuma/plugin/wmctrl.rb
 - lib/fusuma/plugin/wmctrl/version.rb
+- lib/fusuma/plugin/wmctrl/window.rb
+- lib/fusuma/plugin/wmctrl/workspace.rb
 - spec/fusuma/plugin/plugin/executors/wmctrl_executor_spec.rb
+- spec/fusuma/plugin/plugin/wmctrl/workspace_spec.rb
 - spec/fusuma/plugin/wmctrl_spec.rb
 - spec/helpers/config_helper.rb
 - spec/spec_helper.rb
@@ -55,19 +60,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: 2.5.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: Wmctrl plugin for Fusuma
 test_files:
-- spec/fusuma/plugin/plugin/executors/wmctrl_executor_spec.rb
-- spec/fusuma/plugin/wmctrl_spec.rb
 - spec/helpers/config_helper.rb
 - spec/spec_helper.rb
+- spec/fusuma/plugin/wmctrl_spec.rb
+- spec/fusuma/plugin/plugin/executors/wmctrl_executor_spec.rb
+- spec/fusuma/plugin/plugin/wmctrl/workspace_spec.rb