vigilem-evdev 0.1.3

data/spec/vigilem/evdev/system/int_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/system/posix_types'
+
+describe 'int' do
+  it 'defines __u8' do
+    expect(FFI::TypeDefs[:__u8]).not_to be_nil
+  end
+  
+  it 'defines __u8' do
+    expect(FFI::TypeDefs[:__u16]).not_to be_nil
+  end
+  
+  it 'defines __u8' do
+    expect(FFI::TypeDefs[:__u32]).not_to be_nil
+  end
+  
+  it 'defines __u8' do
+    expect(FFI::TypeDefs[:__s8]).not_to be_nil
+  end
+  
+  it 'defines __u8' do
+    expect(FFI::TypeDefs[:__s16]).not_to be_nil
+  end
+  
+  it 'defines __u8' do
+    expect(FFI::TypeDefs[:__s32]).not_to be_nil
+  end
+  
+end

data/spec/vigilem/evdev/system/ioctl_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/system/ioctl'
+
+describe Vigilem::Evdev::System::IOCTL do
+  class C
+    inline do |builder|
+      builder.include '<stdio.h>'
+      builder.include '<sys/ioctl.h>'
+      builder.include '<linux/input.h>'
+      builder.include '<fcntl.h>'
+      builder.include '<stddef.h>'
+      %w(_IOC_NRBITS _IOC_TYPEBITS _IOC_SIZEBITS _IOC_DIRBITS _IOC_NRMASK
+      _IOC_TYPEMASK _IOC_SIZEMASK _IOC_DIRMASK _IOC_NRSHIFT _IOC_TYPESHIFT
+      _IOC_SIZESHIFT _IOC_DIRSHIFT IOCSIZE_MASK IOCSIZE_SHIFT).map do |str|
+        builder.c "
+          long r_#{str}() {
+            return #{str};
+          }
+        "
+      end
+      
+      %w(_IOC_NONE _IOC_WRITE _IOC_READ).map do |str|
+        builder.c "
+          int r_#{str}() {
+            return #{str};
+          }
+        "
+      end
+      
+      builder.c '
+        long r__IO(char type, int nr) {
+          return _IO(type, nr);
+        }
+      '
+      builder.c '
+        long r_int2_IOC(long dir, char type, int nr) {
+          return _IOC(dir, type, nr, sizeof(int[2]));
+        }
+      '
+    end
+  end
+  
+  let(:c) { C.new }
+  
+  it 'will return zero if sudo is not used' do
+    expect(c.r__IOC_NRBITS).not_to eql 0
+  end
+  
+  describe '::_IOC_NRBITS' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_NRBITS).to eql(c.r__IOC_NRBITS)
+    end
+  end
+  
+  describe '::_IOC_TYPEBITS' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_TYPEBITS).to eql(c.r__IOC_TYPEBITS)
+    end
+  end
+  
+  describe '::_IOC_SIZEBITS' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_SIZEBITS).to eql(c.r__IOC_SIZEBITS)
+    end
+  end
+  
+  describe '::_IOC_DIRBITS' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_DIRBITS).to eql(c.r__IOC_DIRBITS)
+    end
+  end
+  
+  describe '::_IOC_NRMASK' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_NRMASK).to eql(c.r__IOC_NRMASK)
+    end
+  end
+  
+  describe '::_IOC_TYPEMASK' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_TYPEMASK).to eql(c.r__IOC_TYPEMASK)
+    end
+  end
+  
+  describe '::_IOC_SIZEMASK' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_SIZEMASK).to eql(c.r__IOC_SIZEMASK)
+    end
+  end
+  
+  describe '::_IOC_DIRMASK' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_DIRMASK).to eql(c.r__IOC_DIRMASK)
+    end
+  end
+  
+  describe '::_IOC_NRSHIFT' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_NRSHIFT).to eql(c.r__IOC_NRSHIFT)
+    end
+  end
+  
+  describe '::_IOC_TYPESHIFT' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_TYPESHIFT).to eql(c.r__IOC_TYPESHIFT)
+    end
+  end
+  
+  describe '::_IOC_SIZESHIFT' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_SIZESHIFT).to eql(c.r__IOC_SIZESHIFT)
+    end
+  end
+  
+  describe '::_IOC_DIRSHIFT' do
+    it 'will match the linux value' do
+      expect(described_class::_IOC_DIRSHIFT).to eql(c.r__IOC_DIRSHIFT)
+    end
+  end
+  
+  describe '::IOCSIZE_MASK' do
+    it 'will match the linux value' do
+      expect(described_class.IOCSIZE_MASK).to eql(c.r_IOCSIZE_MASK)
+    end
+  end
+  
+  describe '::IOCSIZE_SHIFT' do
+    it 'will match the linux value' do
+      expect(described_class.IOCSIZE_SHIFT).to eql(c.r_IOCSIZE_SHIFT)
+    end
+  end
+  
+  describe '::_IOC_NONE' do
+    it 'will match the linux value' do
+      expect(described_class._IOC_NONE).to eql(c.r__IOC_NONE)
+    end
+  end
+  describe '::_IOC_WRITE' do
+    it 'will match the linux value' do
+      expect(described_class._IOC_WRITE).to eql(c.r__IOC_WRITE)
+    end
+  end
+  
+  describe '::_IOC_READ' do
+    it 'will match the linux value' do
+      expect(described_class._IOC_READ).to eql(c.r__IOC_READ)
+    end
+  end
+  
+  let(:i_2) { 'ii' }
+  
+  let(:i_2_length) { ([0] * 2).pack('ii').length }
+  
+  let(:ioc_r) { described_class::_IOC_READ }
+  let(:ioc_n) { described_class::_IOC_NONE }
+  
+  describe '::_IOC' do
+    it 'will match the linux value' do
+      expect(described_class._IOC(ioc_r, 'E', 0x03, i_2_length)).to eql(c.r_int2_IOC(ioc_r, 'E', 0x03))
+    end
+  end
+  
+  
+  describe '::_IO' do
+    it 'will match the linux value' do
+      expect(described_class._IO('E', 0x03)).to eql(c.r__IO('E', 0x03))
+    end
+  end
+  
+  class Macro
+    inline do |builder|
+      builder.include '<stdio.h>'
+      builder.include '<sys/ioctl.h>'
+      builder.include '<fcntl.h>'
+      %w(_IOR _IOW _IOWR).map do |str|
+        builder.c "
+          long #{str.downcase}_int(char type, int nr) {
+            return #{str}(type, nr, int);
+          }
+        "
+      end
+    end
+  end
+  
+  let(:macro) { Macro.new }
+  
+  describe '::_IOR' do
+    it 'will match the linux value' do
+      expect(described_class._IOR('E', 0x03, 'i')).to eql(macro._ior_int('E', 0x03))
+    end
+  end
+  
+  describe '::_IOW' do
+    it 'will match the linux value' do
+      expect(described_class._IOW('E', 0x03, 'i')).to eql(macro._iow_int('E', 0x03))
+    end
+  end
+  
+  describe '::_IOWR' do
+    it 'will match the linux value' do
+      expect(described_class._IOWR('E', 0x03, 'i')).to eql(macro._iowr_int('E', 0x03))
+    end
+  end
+  
+end

data/spec/vigilem/evdev/system/keymap_loaders/dumpkeys_loader_spec.rb

@@ -0,0 +1,5 @@
+require 'vigilem/evdev/system/keymap_loaders/dumpkeys_loader'
+
+describe Vigilem::Evdev::System::KeymapLoaders::DumpkeysLoader do
+
+end

data/spec/vigilem/evdev/system/keymap_loaders/kmap_loader_spec.rb

@@ -0,0 +1,24 @@
+require 'vigilem/evdev/system/keymap_loaders/kmap_loader'
+
+describe Vigilem::Evdev::System::KeymapLoaders::KmapLoader do
+
+  describe '#exec' do
+    it 'looks for plain text kmap file in console-setup' do
+      
+    end
+    
+    it 'looks for a gzipped kmap file' do
+      
+    end
+  end
+  
+  describe '#key_map' do
+  
+  end
+  
+  describe '#key_map_info' do
+  
+  end
+  
+  
+end

data/spec/vigilem/evdev/system/keymap_loaders_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/system/keymap_loaders'
+
+require 'vigilem/evdev/system/keymap_loaders/dumpkeys_loader'
+require 'vigilem/evdev/system/keymap_loaders/kmap_loader'
+
+describe Vigilem::Evdev::System::KeymapLoaders, :clean_up_test_cache do
+  
+  describe '::load_key_map' do
+    it 'raises an error if a keymap cannot be loaded' do
+      described_class.all = []
+      expect { described_class.exec }.to raise_error(NotImplementedError)
+    end
+    
+    it 'loads a key_map attempting multiple sources' do
+      described_class.all += [described_class::KmapLoader.new, described_class::DumpkeysLoader.new]
+      expect(described_class.exec).to be_a Vigilem::Support::KeyMap
+    end
+  end
+  
+end

data/spec/vigilem/evdev/system/posix_types_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/system/posix_types'
+
+describe 'posix_types' do
+  it 'defines FFI type __kernel_long_t' do
+    expect(FFI::TypeDefs[:__kernel_long_t]).not_to be_nil
+  end
+  it 'defines FFI type __kernel_time_t' do
+    expect(FFI::TypeDefs[:__kernel_time_t]).not_to be_nil
+  end
+  it 'defines FFI type __kernel_suseconds_t' do
+    expect(FFI::TypeDefs[:__kernel_suseconds_t]).not_to be_nil
+  end
+end

data/spec/vigilem/evdev/system/time_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/system/time'
+
+describe Vigilem::Evdev::Time do
+  
+  describe described_class::Timeval do
+    describe 'structure' do
+      it 'will respond_to #tv_sec' do
+        expect(subject).to respond_to(:tv_sec)
+      end
+      
+      it 'will respond_to #tv_usec' do
+        expect(subject).to respond_to(:tv_usec)
+      end
+    end
+  end
+end

data/spec/vigilem/evdev/transfer_agent_spec.rb

@@ -0,0 +1,57 @@
+require 'vigilem/evdev/transfer_agent'
+
+describe Vigilem::Evdev::TransferAgent do
+  
+  after(:each) do
+    [(v = ::Vigilem)::Evdev::Multiplexer, v::Evdev::Demultiplexer, 
+      v::Core::Multiplexer, v::Core::Demultiplexer, v::Core::TransferAgent,
+      described_class].each do |klass|
+        klass.instance_variables.each {|ivar| klass.send(:remove_instance_variable, ivar) }
+    end
+  end
+  
+  describe '::acquire' do
+    
+    let(:singleton_var_name) { :@transfer_agent }
+    
+    context 'none exists and called with no args' do
+      it 'the class instance variable will be nil initially' do
+        expect(described_class.instance_variable_get(singleton_var_name)).to be_nil
+      end
+      
+      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
+      
+      it 'sets the class instance variable' do
+        described_class.acquire
+        expect(described_class.instance_variable_get(singleton_var_name)).not_to be_nil
+      end
+    end
+    
+    context 'none exists and called with args' do
+      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 = []
+        expect(described_class.acquire(inputs: [a])).to match(
+          an_object_having_attributes(
+            :demultiplexer => instance_of(Vigilem::Evdev::Demultiplexer),
+            :multiplexer => an_object_having_attributes(:inputs => [a])
+          )
+        )
+      end
+    end
+    
+    context 'one exists' do
+      
+      it 'grabs the existing one' do
+        expect(described_class.acquire).to eql(described_class.instance_variable_get(singleton_var_name))
+      end
+    end
+    
+  end
+  
+end

data/spec/vigilem/evdev/vty_context_filter_spec.rb

@@ -0,0 +1,282 @@
+require 'spec_helper'
+
+require 'vigilem/evdev/vty_context_filter'
+
+require 'vigilem/evdev/system/input'
+
+# @todo based on this system keymap, need to "double"
+describe Vigilem::Evdev::VTYContextFilter, :clean_up_test_cache do
+  
+  let(:key_map_class) { Vigilem::Support::KeyMap }
+  
+  describe '::console_keys' do
+    it 'gets all the /console_\d+/i keys from the keymap' do
+      cmap = described_class.console_keys(Vigilem::Evdev.key_map)
+      expect(cmap.values.all? {|v| v =~ /console_\d+/i}).to be_truthy
+    end
+  end
+  
+  describe 'instance-level' do
+    
+    let(:key_num) { 65 }
+    
+    let(:keycode) { subject.keysym_or_keycode("keycode#{key_num}") }
+    
+    let(:alt_key_num) { 56 }
+    
+    let(:alt_key_sym) { subject.keysym_or_keycode(alt_key_num) }
+    
+    let(:shift_key_sym) { subject.keysym_or_keycode(42) }
+    
+    describe '#initialize' do
+      
+      it %q<initialize's #current_console_num, #current_console_keys, #other_console_keys> do
+        
+        expect([
+          subject.current_console_num,
+          subject.current_console_keys,
+          subject.other_console_keys
+        ]).to match [
+          a_kind_of(Integer), a_kind_of(key_map_class), a_kind_of(key_map_class)
+        ]
+      end
+      
+    end
+    
+    describe '#key_map' do
+      it 'the default is to return Evdev.key_map' do
+        expect(subject.key_map).to eql(Vigilem::Evdev.key_map)
+      end
+      
+      class FakeKmapLoader
+      end
+      
+      it 'can be changed by the argument sent in to initialize' do
+        arg = Vigilem::Support::KeyMap.new({})
+        arg.metadata[:loader] = FakeKmapLoader.new
+        inst = described_class.new(arg)
+        expect(inst.key_map).to eql(arg)
+      end
+    end
+    
+    describe '#keysym' do
+      context 'key_map.metadata[:loader].class.name =~ /KmapLoader/' do
+        it 'converts a keycode to keysym' do
+          expect(subject.keysym("keycode#{alt_key_num}")).to eql(alt_key_sym)
+        end
+      end
+      context 'key_map.metadata[:loader].class.name =~ /DumpkeysLoader/' do
+        it 'converts a keycode to keysym' do
+          a = Vigilem::Evdev::System::KeymapLoaders::DumpkeysLoader.new.exec
+          described_class.new(a)
+          expect(subject.keysym("keycode#{alt_key_num}")).to eql(alt_key_sym)
+        end
+      end
+    end
+    
+    describe '#keysym_or_keycode' do
+      #it '' do
+        
+      #end
+    end
+    
+    describe '#add_key' do
+      it 'adds keys to the current list of keys' do
+        subject.add_key(keycode)
+        expect(subject.current_keys).to eql([keycode])
+      end
+    end
+    
+    describe '#remove_key' do
+      it 'removes a key from the #current_keys' do
+        subject.add_key(alt_key_sym)
+        subject.add_key(shift_key_sym)
+        subject.add_key(keycode)
+        subject.remove_key(alt_key_sym)
+        expect(subject.current_keys).not_to include(alt_key_sym)
+      end
+    end
+    
+    describe '#reverted_vty?' do
+      it 'returns if #was_on? and #current_keys matches one of #current_console_keys' do
+        subject.send(:was_on=, true)
+        subject.current_keys.replace(["control", "alt", "keycode88"])
+        
+        subject.current_console_keys[["control", "alt", "keycode88"]] = "Console_12"
+        expect(subject.reverted_vty?).to be_truthy
+      end
+    end
+    
+    describe '#changed_vty?' do
+      it 'returns if #was_off? and #current_keys matches one of #other_console_keys' do
+        subject.send(:was_off=, true)
+        subject.current_keys.replace(["control", "alt", "keycode88"])
+        
+        subject.other_console_keys[["control", "alt", "keycode88"]] = "Console_12"
+        expect(subject.changed_vty?).to be_truthy
+      end
+    end
+    
+    describe '#on?' do
+      it 'checks is the vty changed' do
+        allow(subject).to receive(:changed_vty?) { false }
+        allow(subject).to receive(:reverted_vty?) { false }
+        expect(subject).to receive(:changed_vty?)
+        subject.on?
+      end
+      
+      it 'checks is the vty changed reverted back' do
+        allow(subject).to receive(:changed_vty?) { false }
+        allow(subject).to receive(:reverted_vty?) { false }
+        expect(subject).to receive(:reverted_vty?)
+        subject.on?
+      end
+      
+      it 'will call on_change with the new status when #changed_vty? == true' do
+        allow(subject).to receive(:changed_vty?) { true }
+        allow(subject).to receive(:reverted_vty?) { false }
+        expect(subject).to receive(:on_change) { described_class::ON }
+        subject.on?
+      end
+      
+      it 'will call on_change with the new status when #reverted_vty? == true' do
+        allow(subject).to receive(:changed_vty?) { false }
+        allow(subject).to receive(:reverted_vty?) { true }
+        expect(subject).to receive(:on_change) { described_class::OFF }
+        subject.on?
+      end
+    end
+    
+    describe '#off?' do
+      it 'performs the same actions as #on?' do
+        allow(subject).to receive(:on?)
+        expect(subject).to receive(:on?)
+        subject.off?
+      end
+      
+      it 'inverts the result of #on?' do
+        expect(subject.off?).to eql(!subject.on?)
+      end
+    end
+    
+    context 'private' do
+      describe '#current_keys_hash_cache' do
+        it 'defaults to the #current_keys.hash' do
+          expect(subject.send(:current_keys_hash_cache)).to eql(subject.current_keys.hash)
+        end
+      end
+      
+      describe '#current_keys_changed?' do
+        it 'returns false when the #hash of #current_keys has not changed' do
+          expect(subject.send(:current_keys_changed? )).to be_falsey
+        end
+        
+        it 'returns true when the #hash of #current_keys changed' do
+          subject.current_keys << 'f7'
+          expect(subject.send(:current_keys_changed? )).to be_truthy
+        end
+        
+      end
+      
+      describe '#current_keys_downcase' do
+        it 'gets the downcase of all #current_keys' do
+          subject.instance_variable_set(:@current_keys, %w(Alt Control keycode63))
+          expect(subject.send(:current_keys_downcase)).to eql(%w(alt control keycode63))
+        end
+        
+        it 'changes when #current_keys changes' do
+          lower = subject.send(:current_keys_downcase)
+          subject.current_keys.replace(%w(Alt Control keycode63))
+          expect(lower).not_to eql(subject.send(:current_keys_downcase))
+        end
+      end
+      
+      describe '#allow_release?' do
+        it 'determines whether the event can be released while #on?' do
+          allow(subject).to receive(:on?) { true }
+          subject.send(:filter_ommisions=, [shift_key_sym.downcase])
+          expect(subject.send(:allow_release?, shift_key_sym.downcase)).to be_truthy
+        end
+        
+        it 'determines whether the event can be released while #off?' do
+          allow(subject).to receive(:on?) { false }
+          subject.send(:filter_ommisions=, [shift_key_sym.downcase])
+          expect(subject.send(:allow_release?, shift_key_sym.downcase)).to be_falsey
+        end
+      end
+      
+      describe '#filter_ommisions=, #filter_ommisions' do
+        it '#filter_ommisions=, sets  #filter_ommisions' do
+          subject.send(:filter_ommisions=, [shift_key_sym.downcase])
+          expect(subject.send(:filter_ommisions)).to eql([shift_key_sym.downcase])
+        end
+      end
+      
+    end #private
+    
+    describe '#current_keys' do
+      it 'defaults to []' do
+        expect(subject.current_keys).to eql([])
+      end
+      
+      it 'updates @current_keys_hash_cache' do
+        ckhc = subject.instance_variable_get(:@current_keys_hash_cache)
+        subject.current_keys
+        expect(ckhc).not_to eql(subject.instance_variable_get(:@current_keys_hash_cache))
+      end
+    end
+    
+    describe '#process' do
+      
+      TestInput = Vigilem::Evdev::System::Input
+      
+      let(:syn_1_event) { TestInput::Event[[12, 9], TestInput::EV_SYN, 1, 1] }
+      
+      let(:syn_2_event) { TestInput::Event[[7, 8], TestInput::EV_SYN, 0, 0] }
+      
+      it 'passes all non EV_KEY events if off? == true' do
+        allow(subject).to receive(:off?) { true }
+        events = [syn_1_event, syn_2_event]
+        expect(subject.process(*events)).to eql(events)
+      end
+      
+      let(:key_a_event) { TestInput::Event[[12, 9], TestInput::EV_KEY, TestInput::KEY_LEFTSHIFT, 1] }
+      
+      let(:key_b_event) { TestInput::Event[[7, 8], TestInput::EV_KEY, TestInput::KEY_LEFTALT, 0] }
+      
+      it 'passes on EV_KEY events if off? == true and not in filter_ommisions' do
+        allow(subject).to receive(:off?) { true }
+        events = [key_a_event, key_b_event]
+        subject.send(:filter_ommisions=, [])
+        expect(subject.process(*events)).to eql(events)
+      end
+      
+      it 'filters out EV_KEY events if off? == false and not in filter_ommisions' do
+        allow(subject).to receive(:off?) { false }
+        events = [key_a_event, key_b_event]
+        subject.send(:filter_ommisions=, [])
+        expect(subject.process(*events)).to eql([])
+      end
+      
+      it 'passes on EV_KEY events if on? == true and in filter_ommisions and value == 0' do
+        allow(subject).to receive(:off?) { false }
+        allow(subject).to receive(:on?) { true }
+        events = [key_a_event, key_b_event]
+        subject.send(:filter_ommisions=, [alt_key_sym.downcase])
+        expect(subject.process(*events)).to eql([key_b_event])
+      end
+      
+      it 'filters on EV_KEY events if off? == true and in filter_ommisions and value == 0' do
+        allow(subject).to receive(:off?) { true }
+        events = [key_a_event, key_b_event]
+        
+        subject.send(:filter_ommisions=, [alt_key_sym.downcase])
+        
+        expect(subject.process(*events)).to eql([key_a_event])
+      end
+      
+    end
+    
+  end
+  
+end