fusuma 2.0.0.pre2 → 2.0.4

data/spec/lib/libinput-list-devices_unavailable.txt

@@ -0,0 +1,36 @@
+Device:           AT Translated Set 2 keyboard
+Kernel:           /dev/input/event4
+Group:            9
+Seat:             seat0, default
+Capabilities:     keyboard 
+Tap-to-click:     n/a
+Tap-and-drag:     n/a
+Tap drag lock:    n/a
+Left-handed:      n/a
+Nat.scrolling:    n/a
+Middle emulation: n/a
+Calibration:      n/a
+Scroll methods:   none
+Click methods:    none
+Disable-w-typing: n/a
+Accel profiles:   n/a
+Rotation:         n/a
+
+Device:           Dell WMI hotkeys
+Kernel:           /dev/input/event9
+Group:            10
+Seat:             seat0, default
+Capabilities:     keyboard 
+Tap-to-click:     n/a
+Tap-and-drag:     n/a
+Tap drag lock:    n/a
+Left-handed:      n/a
+Nat.scrolling:    n/a
+Middle emulation: n/a
+Calibration:      n/a
+Scroll methods:   none
+Click methods:    none
+Disable-w-typing: n/a
+Accel profiles:   n/a
+Rotation:         n/a
+

data/spec/lib/libinput_command_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/libinput_command'
+
+module Fusuma
+  RSpec.describe LibinputCommand do
+    let(:libinput_command) do
+      described_class.new(libinput_options: libinput_options, commands: commands)
+    end
+    let(:libinput_options) { [] }
+    let(:commands) { {} }
+    describe '#version' do
+      subject { libinput_command.version }
+
+      context 'when libinput-list-device is available' do
+        before do
+          allow(libinput_command).to receive('which')
+            .with('libinput') { false }
+          allow(libinput_command).to receive('which')
+            .with('libinput-list-devices') { true }
+          allow_any_instance_of(Kernel).to receive(:`)
+            .with('libinput-list-devices --version') { "1.6.3\n" }
+        end
+
+        it { is_expected.to eq '1.6.3' }
+        it { expect(libinput_command.new_cli_option_available?).to be false }
+      end
+
+      context 'when libinput is available' do
+        before do
+          allow(libinput_command).to receive('which')
+            .with('libinput') { true }
+          allow(libinput_command).to receive('which')
+            .with('libinput-list-devices') { false }
+          allow_any_instance_of(Kernel).to receive(:`)
+            .with('libinput --version') { "1.8\n" }
+        end
+
+        it { is_expected.to eq '1.8' }
+        it { expect(libinput_command.new_cli_option_available?).to be true }
+      end
+
+      context 'when libinput command is not found' do
+        before do
+          allow(libinput_command).to receive('which')
+            .with('libinput') { false }
+          allow(libinput_command).to receive('which')
+            .with('libinput-list-devices') { false }
+        end
+
+        it 'shold print error and exit 1' do
+          expect(MultiLogger).to receive(:error)
+          expect { subject }.to raise_error(SystemExit)
+        end
+      end
+    end
+
+    describe '#new_cli_option_available?' do
+      subject { libinput_command.new_cli_option_available? }
+      context 'with NEW_CLI_OPTION_VERSION' do
+        before do
+          allow(libinput_command).to receive(:version)
+            .and_return(LibinputCommand::NEW_CLI_OPTION_VERSION)
+        end
+        it { is_expected.to eq true }
+      end
+      context 'without NEW_CLI_OPTION_VERSION' do
+        before do
+          allow(libinput_command).to receive(:version)
+            .and_return(LibinputCommand::NEW_CLI_OPTION_VERSION - 0.1)
+        end
+        it { is_expected.to eq false }
+      end
+    end
+
+    describe 'list_devices' do
+      subject { libinput_command.list_devices }
+      after { subject }
+
+      before do
+        dummy_io = StringIO.new('dummy')
+        io = StringIO.new('dummy output')
+        allow(Open3).to receive(:popen3).with(anything).and_return([dummy_io, io, dummy_io,
+                                                                    dummy_io, nil])
+      end
+
+      context 'with the alternative command' do
+        let(:commands) { { list_devices_command: 'dummy_list_devices' } }
+
+        it 'should call dummy events' do
+          expect(Open3).to receive(:popen3).with(/dummy_list_devices/)
+        end
+      end
+
+      context 'with new cli version' do
+        before do
+          allow(libinput_command).to receive(:new_cli_option_available?)
+            .and_return(true)
+        end
+
+        it 'call `libinput list-devices`' do
+          command = 'libinput list-devices'
+          expect(Open3).to receive(:popen3)
+            .with(command)
+        end
+      end
+      context 'with old cli version' do
+        before do
+          allow(libinput_command).to receive(:new_cli_option_available?)
+            .and_return(false)
+        end
+
+        it 'call `libinput-list-devices`' do
+          command = 'libinput-list-devices'
+          expect(Open3).to receive(:popen3)
+            .with(command)
+        end
+      end
+    end
+
+    describe 'debug_events' do
+      before do
+        @dummy_io = StringIO.new('dummy')
+        allow(Process).to receive(:detach).with(anything).and_return(nil)
+      end
+      subject { libinput_command.debug_events(@dummy_io) }
+
+      context 'with the alternative command' do
+        before do
+          allow(libinput_command).to receive(:debug_events_with_options).and_return 'dummy_debug_events'
+        end
+
+        it 'should call dummy events' do
+          expect(Process).to receive(:spawn).with('dummy_debug_events',
+                                                  { out: @dummy_io, in: '/dev/null' }).once
+          subject
+        end
+      end
+    end
+
+    describe '#debug_events_with_options' do
+      subject { libinput_command.debug_events_with_options }
+
+      context 'with new cli version' do
+        before do
+          allow(libinput_command)
+            .to receive(:new_cli_option_available?)
+            .and_return(true)
+        end
+        it { is_expected.to eq 'stdbuf -oL -- libinput debug-events' }
+      end
+
+      context 'with old cli version' do
+        before do
+          allow(libinput_command)
+            .to receive(:new_cli_option_available?)
+            .and_return(false)
+        end
+        it { is_expected.to eq 'stdbuf -oL -- libinput-debug-events' }
+      end
+    end
+  end
+end

data/spec/lib/plugin/base_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require './lib/fusuma/plugin/base'
+require './lib/fusuma/plugin/manager'
+
+module Fusuma
+  module Plugin
+    class DummyPlugin < Base
+      def config_param_types
+        {
+          dummy_string: String,
+          dummy_list: Array,
+          dummy_bool: [TrueClass, FalseClass]
+        }
+      end
+    end
+
+    class DummyChildPlugin < DummyPlugin
+    end
+
+    RSpec.describe DummyPlugin do
+      before do
+        @dummy_plugin = DummyPlugin.new
+        @dummy_child_plugin = DummyChildPlugin.new
+
+        ConfigHelper.load_config_yml = <<-CONFIG
+        plugin:
+          dummy_plugin:
+            dummy_string: dummy
+            dummy_list:
+              - 1
+              - 2
+              - 3
+            dummy_bool: true
+        CONFIG
+      end
+
+      after do
+        Config.custom_path = nil
+      end
+      describe '.inherited' do
+        it 'should add required class to subclass on Manager' do
+          expect(Manager.plugins[Base.name]).to include(DummyPlugin)
+        end
+      end
+
+      describe '.plugins' do
+        it 'should list plugins' do
+          expect(DummyPlugin.plugins).to eq([DummyChildPlugin])
+        end
+      end
+
+      describe '#config_param_types' do
+        it 'should define class for config params' do
+          expect(@dummy_plugin.config_param_types).to be_a Hash
+        end
+      end
+
+      describe '#config_params' do
+        it 'should fetch options from config' do
+          expect(@dummy_plugin.config_params).to be_a Hash
+          expect(@dummy_plugin.config_params(:dummy_string)).to be_a String
+        end
+      end
+
+      describe '#config_index' do
+        it 'should return index' do
+          expect(@dummy_plugin.config_index).to be_a Config::Index
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/buffers/buffer_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require './lib/fusuma/plugin/events/event'
+require_relative './dummy_buffer'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      RSpec.describe DummyBuffer do
+        before do
+          @buffer = DummyBuffer.new
+        end
+
+        describe '#type' do
+          subject { @buffer.type }
+          it { is_expected.to eq 'dummy' }
+        end
+
+        describe '#buffer' do
+          it 'should buffer event' do
+            event = Events::Event.new(tag: 'dummy', record: 'dummy record')
+            expect(@buffer.buffer(event)).to eq [event]
+            expect(@buffer.events).to eq [event]
+          end
+
+          it 'should NOT buffer event' do
+            event = Events::Event.new(tag: 'SHOULD NOT BUFFER', record: 'dummy record')
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq []
+          end
+        end
+
+        describe '#source' do
+          subject { @buffer.source }
+
+          it { is_expected.to eq DummyBuffer::DEFAULT_SOURCE }
+
+          context 'with config' do
+            around do |example|
+              @source = 'custom_event'
+
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                 buffers:
+                   dummy_buffer:
+                     source: #{@source}
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it { is_expected.to eq @source }
+          end
+        end
+
+        describe '#config_params' do
+          around do |example|
+            ConfigHelper.load_config_yml = <<~CONFIG
+              plugin:
+               buffers:
+                 dummy_buffer:
+                   dummy: dummy
+            CONFIG
+
+            example.run
+
+            Config.custom_path = nil
+          end
+
+          subject { @buffer.config_params }
+          it { is_expected.to eq(dummy: 'dummy') }
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/buffers/dummy_buffer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require './lib/fusuma/plugin/buffers/buffer'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      class DummyBuffer < Buffer
+        DEFAULT_SOURCE = 'dummy'
+
+        def config_param_types
+          {
+            source: String,
+            dummy: String
+          }
+        end
+      end
+    end
+  end
+end

data/spec/lib/plugin/buffers/gesture_buffer_spec.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require './lib/fusuma/plugin/events/event'
+require './lib/fusuma/plugin/events/records/gesture_record'
+require './lib/fusuma/plugin/buffers/gesture_buffer'
+
+module Fusuma
+  module Plugin
+    module Buffers
+      RSpec.describe GestureBuffer do
+        before do
+          @buffer = GestureBuffer.new
+          delta = Events::Records::GestureRecord::Delta.new(-1, 0, 0, 0, 0, 0)
+          @event_generator = lambda { |time = nil, status = 'updating'|
+            Events::Event.new(time: time,
+                              tag: 'libinput_gesture_parser',
+                              record: Events::Records::GestureRecord.new(
+                                status: status,
+                                gesture: 'SWIPE',
+                                finger: 3,
+                                delta: delta
+                              ))
+          }
+        end
+
+        describe '#type' do
+          it { expect(@buffer.type).to eq 'gesture' }
+        end
+
+        describe '#buffer' do
+          it 'should buffer gesture event' do
+            event = @event_generator.call
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq [event]
+          end
+
+          it 'should NOT buffer other event' do
+            event = Events::Event.new(tag: 'SHOULD NOT BUFFER', record: 'dummy record')
+            @buffer.buffer(event)
+            expect(@buffer.events).to eq []
+          end
+
+          it 'should buffer begin/end' do
+            begin_event = @event_generator.call(nil, 'begin')
+            @buffer.buffer(begin_event)
+            expect(@buffer.events).to eq [begin_event]
+            end_event = @event_generator.call(nil, 'end')
+            @buffer.buffer(end_event)
+            expect(@buffer.events).to eq [begin_event, end_event]
+          end
+        end
+
+        describe '#clear_expired' do
+          it 'should keep only events generated within 30 seconds' do
+            time = Time.now
+            event1 = @event_generator.call(time)
+            @buffer.buffer(event1)
+            event2 = @event_generator.call(time + 100)
+            event3 = @event_generator.call(time + 100)
+            @buffer.buffer(event2)
+            @buffer.buffer(event3)
+
+            @buffer.clear_expired(current_time: time + 100.1)
+
+            expect(@buffer.events).to eq [event2, event3]
+          end
+
+          context 'change seconds to keep' do
+            around do |example|
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                  buffers:
+                    gesture_buffer:
+                      seconds_to_keep: 0.3
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it 'should keep only events generated within 0.3 seconds' do
+              expect(@buffer.config_params).to eq(seconds_to_keep: 0.3)
+              time = Time.now
+              event1 = @event_generator.call(time)
+              @buffer.buffer(event1)
+              event2 = @event_generator.call(time + 0.1)
+              @buffer.buffer(event2)
+              event3 = @event_generator.call(time + 0.2)
+              @buffer.buffer(event3)
+              @buffer.clear_expired(current_time: time + 0.29)
+              expect(@buffer.events).to eq [event1, event2, event3]
+
+              @buffer.clear_expired(current_time: time + 0.3)
+              expect(@buffer.events).to eq [event2, event3]
+            end
+          end
+        end
+
+        describe '#source' do
+          it { expect(@buffer.source).to eq GestureBuffer::DEFAULT_SOURCE }
+
+          context 'with config' do
+            around do |example|
+              @source = 'custom_event'
+
+              ConfigHelper.load_config_yml = <<~CONFIG
+                plugin:
+                  buffers:
+                    gesture_buffer:
+                      source: #{@source}
+              CONFIG
+
+              example.run
+
+              Config.custom_path = nil
+            end
+
+            it { expect(@buffer.source).to eq @source }
+          end
+        end
+
+        describe '#sum_attrs' do
+          it 'should calculate the sum of each attribute'
+        end
+
+        describe '#avg_attrs' do
+          it 'should calculate the average of each attribute'
+        end
+
+        describe '#finger' do
+          it 'should return number of fingers in gestures'
+        end
+
+        describe '#gesture' do
+          it 'should return string of gesture type'
+        end
+
+        describe '#empty?' do
+          context 'no gestures in buffer' do
+            before { @buffer.clear }
+            it { expect(@buffer.empty?).to be true }
+          end
+
+          context 'buffered some gestures' do
+            before { @buffer.buffer(@event_generator.call) }
+            it { expect(@buffer.empty?).to be false }
+          end
+        end
+
+        describe '#slect_by_events' do
+          context 'without block' do
+            it { expect(@buffer.select_by_events).to be_a Enumerator }
+          end
+
+          context 'with block' do
+            before do
+              @e1 = @event_generator.call(nil, 'hoge')
+              @e2 = @event_generator.call(nil, 'hoge')
+              @e3 = @event_generator.call(nil, 'fuga')
+              [@e1, @e2, @e3].each { |event| @buffer.buffer(event) }
+            end
+            it { expect(@buffer.select_by_events { |e| e.record.status == 'hoge' }).to be_a GestureBuffer }
+            it { expect(@buffer.select_by_events { |e| e.record.status == 'hoge' }.events).to eq [@e1, @e2] }
+          end
+        end
+      end
+    end
+  end
+end