fusuma-plugin-wmctrl 0.4.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37b4a5e6419c6747eabf01018d034c02b5cca98ffb7b523fe1d33f7cce03859a
-  data.tar.gz: bc8c76aef630cbed08ad068af3cac600dc105821cd8b18ae75477ae2dc7ae35a
+  metadata.gz: 260a70ddbdd31218d0e43a7c354482b44d1cc17aaf7ece9fe3800ce7bf156c72
+  data.tar.gz: 0a15ae0fbe6c080fccc5e460400a3b77e062079e00f0a90dabdfb43d3c5d4dd2
 SHA512:
-  metadata.gz: 4e4a0404a5be2a300a6b1cf9ac40a8fbb0d5061173530d5e24a255b18b741bb0687b580b016f54930676bbe2af20842aa09aa07e0065d3cfbf5fb0bc6958e64e
-  data.tar.gz: 98afa73285943a1bef00cbe0bba092fd35cab401cd2b1503926981fd404271d6c05b73e4164e65e0f98a3623b6da61b089619455dcb7f44af4d447d0c82bd9d2
+  metadata.gz: e07ea3be6ceed205615ba3f22e57519b3dfad5e3fba29c099fffc35afa542bb33eef7c2143962cd1c987127b13472780c45f99f03d3f07e5e0ce9afda6e63178
+  data.tar.gz: a0fa6b1ba117356a3062a30e11c2f3969a2382c4adbd2b0327c03dbb404f89d9ed71d4564dbde8588d798b5297af46ad429efa7f64517ec807bbc5e57babf80b

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/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.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.0'
 end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'singleton'
+require_relative '../wmctrl/window'
+require_relative '../wmctrl/workspace'
 
 module Fusuma
   module Plugin
@@ -15,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 = Workspace.new(
+            wrap_navigation: config_params(:'wrap-navigation'),
+            matrix_col_size: config_params(:'matrix-col-size')
+          )
+          @window = Window.new
         end
 
         # execute wmctrl command
@@ -49,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
@@ -59,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]
@@ -73,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.3'
+      VERSION = '1.0.0'
     end
   end
 end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# 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

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# Manage workspace
+class Workspace
+  class InvalidOption < 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
+
+    warn(<<~ERRRORMESSAGE)
+      Please set matrix-col-size to config.yml
+
+      ```config.yaml
+      plugin:
+        executors:
+          wmctrl_executor:
+            matrix-col-size: 2
+      ```
+    ERRRORMESSAGE
+    raise InvalidOption, '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

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(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
-
-          @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(Process)
-              .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(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(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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fusuma-plugin-wmctrl
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 1.0.0
 platform: ruby
 authors:
 - iberianpig
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-04-20 00:00:00.000000000 Z
+date: 2021-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fusuma
@@ -39,7 +39,10 @@ files:
 - 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,7 +58,7 @@ 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:
   - - ">="
@@ -67,6 +70,7 @@ signing_key:
 specification_version: 4
 summary: Wmctrl plugin for Fusuma
 test_files:
+- spec/fusuma/plugin/plugin/wmctrl/workspace_spec.rb
 - spec/fusuma/plugin/plugin/executors/wmctrl_executor_spec.rb
 - spec/fusuma/plugin/wmctrl_spec.rb
 - spec/helpers/config_helper.rb