vigilem-evdev 0.1.3

data/spec/vigilem/evdev/demultiplexer_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/demultiplexer'
+
+describe Vigilem::Evdev::Demultiplexer do
+  
+  after(:each) do
+    (described_class.instance_variables).each do |ivar|
+      described_class.send(:remove_instance_variable, ivar)
+    end
+  end
+  
+  describe '::acquire' do
+    context 'none exists and called with no args' do
+      it 'creates a new one' do
+        allow(described_class).to receive(:new).and_call_original
+        expect(described_class).to receive(:new)
+        expect(described_class.acquire()).to be_a described_class
+      end
+    end
+    
+    context 'none exists and called with args' do
+      
+      class FakeStream
+        def update(*events)
+        end
+      end
+      
+      it 'creates a new one with given args' do
+        allow(described_class).to receive(:new).and_call_original
+        expect(described_class).to receive(:new)
+        a = []
+        obs = FakeStream.new
+        expect(described_class.acquire([obs])).to match(
+          an_object_having_attributes(
+            :observers => [obs]
+          )
+        )
+      end
+    end
+    
+  end
+  
+end

data/spec/vigilem/evdev/device_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/device'
+
+describe Vigilem::Evdev::Device do
+  
+  after_each_example_group do
+    (described_class.instance_variables).each do |ivar| 
+      described_class.instance_variable_set(ivar, nil)
+    end
+  end
+  
+  describe '::open' do
+    
+    #@todo this is system dependent and will fail if no events in '/dev/input'
+    it 'opens a device based on device path' do
+      expect(described_class.open('/dev/input/event1')).to be_a described_class
+    end
+    
+    it 'adds a new Device to the ::all Array' do
+      dev = described_class.open('/dev/input/event1')
+      expect(described_class.all).to include(dev)
+    end
+    
+    it 'returns an existing Device is there is one' do
+      dev = described_class.open('/dev/input/event1')
+      expect(described_class.open('/dev/input/event1')).to eql(dev)
+    end
+    
+  end
+  
+  describe '::all' do
+    
+    it 'to checks the default_dir' do
+      allow(described_class).to receive(:chardev_glob) { [] }
+      expect(described_class).to receive(:chardev_glob).with('/dev/input/event*')
+      described_class.all
+    end
+  end
+  
+  describe '::default_dir' do
+    it 'will defaults to "/dev/input"' do
+      expect(described_class.default_dir).to eql('/dev/input')
+    end
+  end
+  
+  describe '::default_glob' do
+    it 'will default to "/dev/input/event*"' do
+      expect(described_class.default_glob()).to eql('/dev/input/event*')
+    end
+  end
+  
+  describe '#name' do
+    it 'gets the EVIOCGNAME of the device' do
+      expect(described_class.open('/dev/input/event2').name).to be_a(String) and not be_empty
+    end
+  end
+  
+  describe '::name_grep' do
+    
+    before(:each) do
+      allow(described_class).to receive(:EVIOCGNAME) { "AT Translated Set 2 keyboard#{'\x00' * 229}" }
+    end
+    
+    it %q<greps the EVIOCGNAME's of existing devices> do
+      #expect(described_class.name_grep(/keyboard/)).to eql([instance_of(described_class)]) #hangs?
+      expect(described_class.name_grep(/keyboard/)).to match [instance_of(described_class)]
+    end
+  end
+  
+  describe '::chardev_glob' do
+    it 'globs a dir and returns an Array of chacter device file paths' do
+      pending('testable isolated chardev')
+      expect(described_class.chardev_glob(char_device_glob)).to eql(char_device)
+    end
+    
+    it 'defaults to the current dir' do
+      allow(Dir).to receive(:[]).with('./*') { [] }
+      expect(Dir).to receive(:[]).with('./*')
+      described_class.chardev_glob
+    end
+  end
+  
+  describe '::open' do
+    it 'opens a device based on device path' do
+      expect(described_class.open('/dev/input/event1')).to be_a described_class
+    end
+  end
+  
+  describe '#ids' do
+    it %q<gets the id's of the device> do
+      pending('implementeation gets fixed')
+      expect(described_class.open('/dev/input/event2').ids).to eql([instance_of(Integer)] * 4)
+    end
+  end
+  
+end

data/spec/vigilem/evdev/dom/adapter_spec.rb

@@ -0,0 +1,5 @@
+require 'vigilem/evdev/dom/adapter'
+
+describe Vigilem::Evdev::DOM::Adapter do
+
+end

data/spec/vigilem/evdev/dom/input_event_converter_spec.rb

@@ -0,0 +1,253 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/dom/input_event_converter'
+
+describe Vigilem::Evdev::DOM::InputEventConverter, :clean_up_test_cache do
+  
+  Input = Vigilem::Evdev::System::Input
+  
+  InputEvent = Input::Event
+  
+  class Host
+    include Vigilem::Evdev::DOM::InputEventConverter
+    
+    def initialize
+      initialize_input_event_converter
+    end
+    
+  end
+  
+  subject { Host.new }
+  
+  let(:input_event) do 
+    ie = InputEvent[[12, 9], 1, Input::KEY_A, 1]
+    ie.leds = "100000000000000000000000"
+    ie
+  end
+  
+  let(:input_event_release) do 
+    ie = InputEvent[[15, 11], 1, Input::KEY_A, 0]
+    ie.leds = "100000000000000000000000"
+    ie
+  end
+  
+  describe '#key_map' do
+    it 'returns a keymap' do
+      expect(subject.key_map).to be_a Vigilem::Support::KeyMap
+    end
+  end
+  
+  describe '#keysyms' do
+    it 'takes a alpha keycode name and returns it\'s key_syms' do
+      expect(subject.keysyms('keycode30')).to match(/\+?(U\+)?(0x)?0061/)
+    end
+    
+    it 'takes a functional keycode name and returns it\'s key_syms' do
+      expect(subject.keysyms('keycode97')).to match(/[a-z]+/i)
+    end
+  end
+  
+  describe 'dom_key' do
+    
+    it 'takes a keycode string for an alpha char and returns the dom key' do
+      expect(subject.dom_key(input_event.code, subject.leds("100000000000000000000000"))).to eql('a')
+    end
+    
+    it 'takes an InputEvent.code for a control char and returns a dom key' do
+      input_event[:code] = Input::KEY_RIGHTCTRL
+      expect(subject.dom_key(input_event.code, subject.leds("100000000000000000000000"))).to eql('Control')
+    end
+  end
+  
+  describe '#dom_type' do
+    
+    let(:dom_key_value) { subject.dom_key(input_event.code, subject.leds("100000000000000000000000")) }
+    
+    it %<takes an 0 and returns ['keydown', 'keypress']> do
+      expect(subject.dom_type(input_event.value, dom_key_value)).to eql(%w(keydown keypress))
+    end
+    
+    it %<takes an 0 and with a non-printable character returns ['keydown']> do
+      expect(subject.dom_type(input_event.value, 'Control')).to eql(%w(keydown))
+    end
+    
+    it %<takes an 1 and returns 'keyup'> do
+      input_event[:value] = 0
+      expect(subject.dom_type(input_event.value, dom_key_value)).to eql(['keyup'])
+    end
+  end
+  
+  describe '#dom_code' do
+    it 'takes an InputEvent with an alpha code and returns the DOM code value' do
+      keycode_name = described_class::KEYCODES[event_code = input_event.code]
+      expect(subject.dom_code(keycode_name, 
+        subject.dom_key(event_code, subject.leds("100000000000000000000000")))
+      ).to eql('KeyA')
+    end
+    
+    it 'takes an InputEvent with an numeric code and returns the DOM code value' do
+      keycode_name = described_class::KEYCODES[event_code = Input::KEY_4]
+      expect(subject.dom_code(keycode_name, 
+        subject.dom_key(event_code, subject.leds("100000000000000000000000")))
+      ).to eql('Digit4')
+    end
+    
+    it 'takes an InputEvent.code for a control char and returns a dom key' do
+      expect(subject.dom_code(Input::KEY_RIGHTCTRL, 
+          subject.dom_key(Input::KEY_RIGHTCTRL, subject.leds("100000000000000000000000")))
+        ).to eql('ControlRight')
+    end
+  end
+  
+  describe '#dom_location' do
+    it 'takes an input event code and returns dom location' do
+      keycode_name = described_class::KEYCODES[Input::KEY_RIGHTCTRL]
+      expect(subject.dom_location(keycode_name)).to eql(2)
+    end
+  end
+  
+  describe '#dom_modifiers' do
+    it 'takes an input event code and returns dom modifiers' do
+      keycode_name = described_class::KEYCODES[Input::KEY_RIGHTCTRL]
+      expect(subject.dom_modifiers(keycode_name)).to eql({
+        :altKey => false, :ctrlKey => true, :keyModifierStateAltGraph => false,
+        :keyModifierStateCapsLock => false, :keyModifierStateFn => false,
+        :keyModifierStateFnLock => false, :keyModifierStateHyper => false,
+        :keyModifierStateNumLock => false, :keyModifierStateOS => false,
+        :keyModifierStateScrollLock => false, :keyModifierStateSuper => false,
+        :keyModifierStateSymbol => false, :keyModifierStateSymbolLock => false,
+        :metaKey => false, :shiftKey => false })
+    end
+  end
+  
+  describe '#current_keys' do
+    it 'defaults to an empty array' do
+      expect(subject.current_keys).to eql([])
+    end
+  end
+  
+  let(:dom_rshift_down) do 
+    VDOM::KeyboardEvent.new('keydown', key: 'shift', code: 'ShiftRight', 
+      location: VDOM::KeyboardEvent::DOM_KEY_LOCATION_RIGHT, repeat: false)
+  end
+  
+  let(:dom_rshift_press) do 
+    VDOM::KeyboardEvent.new('keypress', key: 'shift', code: 'ShiftRight', 
+      location: VDOM::KeyboardEvent::DOM_KEY_LOCATION_RIGHT, repeat: false)
+  end
+  
+  let(:dom_lalt_down) do 
+    VDOM::KeyboardEvent.new('keydown', key: 'alt', code: 'AltRight', 
+      location: VDOM::KeyboardEvent::DOM_KEY_LOCATION_LEFT, repeat: false)
+  end
+  
+  let(:dom_lalt_press) do 
+    VDOM::KeyboardEvent.new('keypress', key: 'alt', code: 'AltRight', 
+      location: VDOM::KeyboardEvent::DOM_KEY_LOCATION_LEFT, repeat: false)
+  end
+  
+  describe '#current_mod_keys_w_loc' do
+    it 'defaults to an empty array' do
+      expect(subject.current_mod_keys_w_loc).to eql([])
+    end
+    
+    it 'converts current keys that are modifiers and returns an array containing the key and location' do
+      subject.current_keys.replace([dom_rshift_down, dom_rshift_press, dom_lalt_down, dom_lalt_press])
+      expect(subject.current_mod_keys_w_loc).to eql([["shift", "r"], ["alt", "l"]])
+    end
+  end
+  
+  let(:key_hash) do
+    {
+      bubbles: false, cancelable: false,
+      code: 'KeyA', detail: 0, isTrusted: true, isComposing: false, 
+      key: 'a', location: 0, 
+      modifier_state: {"Accel"=>false, "Alt"=>false, "AltGraph"=>false,
+         "CapsLock"=>false, "Control"=>false, "Fn"=>false,
+         "FnLock"=>false, "Hyper"=>false, "Meta"=>false,
+         "NumLock"=>false, "OS"=>false, "ScrollLock"=>false,
+         "Shift"=>false, "Super"=>false, "Symbol"=>false, 
+         "SymbolLock"=>false
+      }, 
+      os_specific: {
+        :time=> {:tv_sec=>12, :tv_usec=>9}, 
+        :type=>1, :code=>Input::KEY_A, :value=>1
+      }, repeat: false, timeStamp: kind_of(Integer), type: 'keydown',
+      view: nil
+    }
+  end
+  
+  let(:key_press_hash) { key_hash.dup.tap {|obj| obj[:type] = 'keypress' } }
+        
+  let(:dom_a_keydown) do
+    ::VDOM::KeyboardEvent.new(key_hash[:type], key_hash)
+  end
+  
+  let(:dom_a_keypress) do
+    ::VDOM::KeyboardEvent.new(key_press_hash[:type], key_press_hash)
+  end
+  
+  describe '#remove_from_current_keys' do
+    it %q<#delete's items from #current_keys> do
+      subject.current_keys.concat([dom_a_keydown, dom_a_keypress])
+      subject.remove_from_current_keys(key_hash[:os_specific], key_hash[:location])
+      expect(subject.current_keys).to eql([])
+    end
+  end
+  
+  describe '#to_dom_key_event' do
+    
+    context 'alpha character' do
+    
+      before(:all) { @converter = Host.new }
+      
+      it 'converts input_events to dom key event' do
+        expect(@converter.to_dom_key_event(input_event)).to match [
+            an_object_having_attributes(key_hash),
+            an_object_having_attributes(key_press_hash)
+          ] and be_a Vigilem::DOM::KeyboardEvent
+      end
+      
+      it 'adds to the #current_keys' do
+        expect(@converter.current_keys).to match [
+            an_object_having_attributes(key_hash),
+            an_object_having_attributes(key_press_hash)
+          ] and be_a Vigilem::DOM::KeyboardEvent
+      end
+      
+      it 'removes items from the #current_keys' do
+        @converter.current_keys.concat([dom_a_keydown, dom_a_keypress])
+        
+        @converter.to_dom_key_event(input_event_release)
+        expect(@converter.current_keys).to eql([])
+      end
+    end
+    
+    context 'functional character' do
+      before(:all) { @converter = Host.new }
+      
+      let(:key_hash_functional) do 
+        key_hash[:key] = 'Control'
+        key_hash[:code] = 'ControlLeft'
+        key_hash[:modifier_state]['Control'] = true
+        key_hash[:location] = 1
+        key_hash[:os_specific][:code] = Input::KEY_LEFTCTRL
+        key_hash
+      end
+      
+      it 'converts input_events to dom key event' do
+        input_event[:code] = Input::KEY_LEFTCTRL
+        expect(@converter.to_dom_key_event(input_event)).to match [
+            an_object_having_attributes(key_hash_functional)
+          ] and be_a Vigilem::DOM::KeyboardEvent
+      end
+      
+      it 'adds to the #current_keys' do
+        expect(@converter.current_keys).to match [
+            an_object_having_attributes(key_hash_functional)
+          ] and be_a Vigilem::DOM::KeyboardEvent
+      end
+    end
+  end
+  
+end

data/spec/vigilem/evdev/dom/input_event_utils_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/dom/input_event_utils'
+
+describe Vigilem::Evdev::DOM::InputEventUtils, :clean_up_test_cache do
+  describe '#event_code_to_keycode_str' do
+    it 'converts a InputEvent#code to a keycode\d+' do
+      expect(subject.event_code_to_keycode_str(30)).to eql('keycode30')
+    end
+  end
+  
+  describe '#location_str_from_keycode_name' do
+    it 'gets the location from the keycode_name' do
+      expect(subject.location_str_from_keycode_name('KEY_RIGHTCTRL')).to eql('Right')
+    end
+  end
+  
+  describe '#modifier_keymap_name' do
+    it 'takes a modifier keycode name and returns it\'s keymap equivilant' do
+      expect(subject.modifier_keymap_name('KEY_RIGHTCTRL')).to eql('ctrlr')
+    end
+  end
+end

data/spec/vigilem/evdev/focus_context_filter_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/focus_context_filter'
+
+describe Vigilem::Evdev::FocusContextFilter, :clean_up_test_cache do
+  
+  describe '::env_display' do
+    it 'pulls the display from the environment variable' do
+      allow(ENV).to receive(:[]).with('DISPLAY') { ':0.0' }
+      expect(ENV).to receive(:[]).with('DISPLAY')
+      described_class.env_display
+    end
+  end
+  
+  context 'instance-level' do
+    
+    before(:all) do
+      described_class.lazy_require
+    end
+    
+    describe '#has_focus?' do
+      it 'uses the X11 function to check for focus' do
+        allow(Xlib).to receive(:XGetInputFocus)
+        expect(Xlib).to receive(:XGetInputFocus)
+        subject.has_focus?
+      end
+      
+      it 'checks XQueryTree because GTK puts the focus on a child window' do
+        allow(Xlib).to receive(:XQueryTree)
+        expect(Xlib).to receive(:XQueryTree)
+        subject.has_focus?
+      end
+    end
+    
+    describe '#has_focus?' do
+      context 'initial focus' do
+        it 'will check the X11 for focus' do
+          allow(Xlib).to receive(:XGetInputFocus)
+          expect(Xlib).to receive(:XGetInputFocus)
+          subject.has_focus?
+        end
+      end
+    end
+    
+    describe '#had_focus?' do
+      it 'will be the opposite of #was_on?' do
+        expect(subject.was_on?).to eql(!subject.had_focus?)
+      end
+    end
+    
+    describe '#had_focus=' do
+      it 'will set the #had_focus?' do
+        subject.send(:had_focus=, true)
+        expect(subject.had_focus?).to be_truthy
+      end
+    end
+    
+    describe '#gained_focus?,' do
+      it 'returns false when event the window already #had_focus?' do
+        subject.send(:had_focus=, true)
+        expect(subject.gained_focus?).to be_falsey
+      end
+      
+      it 'returns true when not #had_focus? and #has_focus?' do
+        subject.send(:had_focus=, false)
+        allow(subject).to receive(:has_focus?) { true }
+        expect(subject.gained_focus?).to be_truthy
+      end
+    end
+    
+    describe '#lost_focus?,' do
+      it 'returns true when #had_focus? and not #has_focus?' do
+        subject.send(:had_focus=, true)
+        allow(subject).to receive(:has_focus?) { false }
+        expect(subject.lost_focus?).to be_truthy
+      end
+      
+      it 'returns false when not #had_focus?' do
+        allow(subject).to receive(:has_focus?) { false }
+        subject.send(:had_focus=, false)
+        expect(subject.lost_focus?).to be_falsey
+      end
+    end
+    
+    describe '#on?' do
+      it 'sets #last_known_status = OFF when #gained_focus? == true' do
+        allow(subject).to receive(:gained_focus?) { true }
+        subject.on?
+        expect(subject.last_known_state).to eql(described_class::OFF)
+      end
+      
+      it 'when #gained_focus? == true, it returns false' do
+        allow(subject).to receive(:gained_focus?) { true }
+        expect(subject.on?).to eql(false)
+      end
+      
+      it 'sets #last_known_status = ON when #lost_focus? == true' do
+        allow(subject).to receive(:gained_focus?) { false }
+        allow(subject).to receive(:lost_focus?) { true }
+        subject.on?
+        expect(subject.last_known_state).to eql(described_class::ON)
+      end
+      
+      it 'when #lost_focus? == true, it returns true' do
+        allow(subject).to receive(:gained_focus?) { false }
+        allow(subject).to receive(:lost_focus?) { true }
+        expect(subject.on?).to eql(true)
+      end
+    end
+    
+  end
+end