vigilem-evdev 0.1.3

data/lib/vigilem/evdev/system/posix_types.rb

@@ -0,0 +1,5 @@
+require 'ffi'
+
+FFI.typedef :long, :__kernel_long_t
+FFI.typedef :__kernel_long_t, :__kernel_time_t
+FFI.typedef :int, :__kernel_suseconds_t

data/lib/vigilem/evdev/system/time.rb

@@ -0,0 +1,21 @@
+require 'vigilem/support'
+
+require 'vigilem/evdev/system/posix_types'
+
+module Vigilem
+module Evdev
+module Time
+  # represents timeval from time.h
+  class Timeval < ::VFFIStruct
+    layout_with_methods :tv_sec, :__kernel_time_t,
+                        :tv_usec, :__kernel_suseconds_t
+    
+    # 
+    # @return [Numeric]
+    def to_f
+      tv_sec.to_f + (tv_usec.to_f/1000000.0)
+    end
+  end
+end
+end
+end

data/lib/vigilem/evdev/transfer_agent.rb

@@ -0,0 +1,40 @@
+require 'vigilem/core/transfer_agent'
+
+require 'vigilem/evdev/demultiplexer'
+
+require 'vigilem/evdev/multiplexer'
+
+module Vigilem
+module Evdev
+  # 
+  # 
+  class TransferAgent < Core::TransferAgent
+    
+    class << self
+      
+      # @todo move away from singleton and look at the one used by x11
+      # @param  args [Hash]
+      # @param  :inputs [Array]
+      # @param  :outputs [Hash{observer_object => {event_opts}] 
+      #         @see Demultiplexer#add_oberver
+      # @return [TransferAgent]
+      def acquire(args={})
+        if @transfer_agent
+          @transfer_agent.multiplexer.add_inputs(*args[:inputs]) if args[:inputs]
+          @transfer_agent.add_observers(args[:outputs]) if args[:outputs]
+          if ((din = @transfer_agent.demultiplexer.input) || (mout = @transfer_agent.multiplexer.out)).nil? or not mout.equal?(din)
+            @transfer_agent.demultiplexer.input = @transfer_agent.multiplexer.out = (mout || din || [])
+          end
+          @transfer_agent
+        else
+          m = Multiplexer.acquire(args[:inputs])
+          d = Demultiplexer.acquire(args[:outputs])
+          @transfer_agent = new(d, m)
+        end
+      end
+      
+    end
+    
+  end
+end
+end

data/lib/vigilem/evdev/version.rb

@@ -0,0 +1,5 @@
+module Vigilem
+module Evdev
+  VERSION = '0.1.3'
+end
+end

data/lib/vigilem/evdev/vty_context_filter.rb

@@ -0,0 +1,216 @@
+require 'vigilem/support/core_ext'
+
+require 'vigilem/support/key_map'
+
+require 'vigilem/_evdev'
+
+require 'vigilem/evdev/context_filter'
+
+module Vigilem
+module Evdev
+  # 
+  # filters events if the VTY differs from the one of this process
+  class VTYContextFilter
+    
+    KeyMap = Support::KeyMap
+    
+    include ContextFilter
+    # @todo make these class_methods
+    attr_reader :current_console_num, :console_keys, 
+           :current_console_keys, :other_console_keys
+    
+    # 
+    # @param  [KeyMap] keymap
+    # @return 
+    def initialize(keymap=Evdev.key_map)
+      @key_map = keymap unless keymap.eql? Evdev.key_map
+      
+      @current_console_num = `fgconsole`.rstrip.to_i
+      curr_con_keys, oth_con_keys = 
+        self.class.console_keys(keymap).partition {|syms,v| v == "Console_#{@current_console_num}" }
+      @current_console_keys, @other_console_keys = KeyMap[curr_con_keys], KeyMap[oth_con_keys]
+      
+      @current_console_keys.left_side_aliases(:keycode, :keycodes)
+      @current_console_keys.right_side_aliases(:keysym, :keysyms)
+      
+      @other_console_keys.left_side_aliases(:keycode, :keycodes)
+      @other_console_keys.right_side_aliases(:keysym, :keysyms)
+      
+      @current_keys = []
+    end
+    
+    # 
+    # @param  [KeyMap] keymap
+    # @return [KeyMap]
+    def self.console_keys(keymap)
+      @console_keys = if keymap.metadata[:loader].class.name =~ /KmapLoader/
+          keymap.select {|k,v| v =~ /console_\d+/i }
+        else
+          console_syms = keymap.info.keysyms.select {|k,v| v =~ /console_\d+/i }
+          tmp = keymap.select {|k,v| v =~ /^#{console_syms.keys.join('|')}$/ } 
+          tmp.each {|k,v| tmp[k] = console_syms[v] }
+        end
+    end
+    
+    # 
+    # @return [KeyMap]
+    def key_map
+      @key_map || Evdev.key_map
+    end
+    
+    # 
+    # @return [Array]
+    def current_keys
+      if @current_keys and current_keys_changed? 
+        max_and_one = KeyMap.mod_weights.values.max + 1
+        @current_keys.sort_by! {|ksym| KeyMap.mod_weights[ksym.downcase] || max_and_one }
+        @current_keys_hash_cache = @current_keys.hash
+        @current_keys
+      else
+        if @current_keys.nil?
+          @current_keys = []
+          @current_keys_hash_cache = @current_keys.hash
+        end
+        @current_keys
+      end
+    end
+    
+    # 
+    # @param  [Array<System::InputEvent>] events
+    # @return [Array]
+    def process(*events)
+      events.select do |event|
+        off_status = off?
+        key_check = if event.type == System::Input::EV_KEY
+          if event.value == 1
+            add_key(keysym_or_keycode(event.code))
+            off_status
+          elsif event.value == 0
+            kork = keysym_or_keycode(event.code)
+            release_status = allow_release?(kork)
+            remove_key(kork)
+            release_status
+          end
+        end
+        if key_check.nil? then off_status else key_check end
+      end
+    end
+    
+    # 
+    # @param  key
+    # @return [Array]
+    def add_key(keycode_or_keysym)
+      current_keys << keycode_or_keysym
+    end
+    
+    # 
+    # @param  [Fixnum] key_num
+    # @return 
+    def remove_key(keycode_or_keysym)
+      current_keys.delete(keycode_or_keysym)
+    end
+    
+    # 
+    # @todo   name
+    # @return [String] 
+    def keysym_or_keycode(key_num)
+      sym = keysym(keycode = "keycode#{key_num}")
+      if sym =~ /shift|alt|c(on)?tro?l|capsshift/i
+        sym
+      else
+        keycode
+      end
+    end
+    
+    # @todo   move to KeyMapUtils, or something like that
+    # @param  [Integer] key_num
+    # @return [String]
+    def keysym(keycode)
+      if key_map.metadata[:loader].class.name =~ /KmapLoader/
+        key_map.keysym(keycode)
+      else
+        key_map.info.keysyms[key_map.char_ref(keycode)]
+      end
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass || NilClass]
+    def on?
+      if changed_vty?
+        self.filter_ommisions = current_keys_downcase
+        on_change(ON)
+      elsif reverted_vty?
+        self.filter_ommisions = current_keys_downcase
+        on_change(OFF)
+      end
+      was_on?
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def reverted_vty?
+      was_on? and current_console_keys.keysym(current_keys_downcase)
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def changed_vty?
+      was_off? and other_console_keys.keysym(current_keys_downcase)
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass]
+    def off?
+      not on?
+    end
+    
+   private
+    # 
+    # @return [Integer] the hash of current_keys last time it was set
+    def current_keys_hash_cache
+      @current_keys_hash_cache ||= @current_keys.hash
+    end
+    
+    # 
+    # @return [TrueClass || FalseClass] if the cached value of 
+    #          #current_keys.hash changed
+    def current_keys_changed?
+      current_keys_hash_cache != @current_keys.hash
+    end
+    
+    # @todo   name!
+    # @return [Array]
+    def current_keys_downcase
+      downcase_hash ||= 0
+      if @current_keys_downcase.nil? or current_keys_hash_cache != downcase_hash
+        downcase_hash = current_keys_hash_cache
+        @current_keys_downcase = current_keys.map(&:downcase)
+      else
+        @current_keys_downcase
+      end
+    end
+    
+   private
+    attr_writer :filter_ommisions
+    
+    # 
+    # @param  other
+    # @return [TrueClass || FalseClass]
+    def allow_release?(keycode_or_keysym)
+      lower_kork = keycode_or_keysym.downcase
+      if filter_ommisions.include? lower_kork
+        filter_ommisions.delete(lower_kork)
+        on?
+      else
+        off?
+      end
+    end
+    
+    # 
+    # @return [Array]
+    def filter_ommisions
+      @filter_ommisions ||= []
+    end
+  end
+end
+end

data/spec/after_each_example_group.rb

@@ -0,0 +1,29 @@
+# 
+# fires after every example_group
+module AfterEachExampleGroup
+  def after_each_example_group?
+    @after_each_example_group_flag ||= false
+  end
+  
+  def after_each_example_group(&block)
+    if block
+      @after_each_example_group_flag = true
+      @after_each_example_group = block
+    else
+      @after_each_example_group
+    end
+  end
+end
+
+RSpec.configure do |config|
+  
+  config.before :all do |example_group|
+    if ((egc = example_group.class).respond_to? :after_each_example_group? and egc.after_each_example_group?)
+      (egc.descendants - [egc]).map do |eg|
+        eg.append_after(:context, &egc.after_each_example_group)
+      end
+    end
+  end
+  
+  config.extend AfterEachExampleGroup
+end

data/spec/delete_test_cache_after_group.rb

@@ -0,0 +1,26 @@
+RSpec.configure do |config|
+  
+  config.before :all do |example_group|
+    klass = example_group.class
+    
+    (klass.descendants - [klass]).each do |egc|
+      if egc.metadata.key?(:clean_up_test_cache)
+        require 'fileutils'
+        require 'vigilem/evdev/key_map_cache'
+        test_name = 'key_map_cache_test'
+        egc.before(:each) do
+          Vigilem::Evdev::KeyMapCache.default_path = nil
+          Vigilem::Evdev::KeyMapCache.default_filename = test_name
+        end
+        egc.after(:each) do
+          Vigilem::Evdev::KeyMapCache.default_path = nil
+          Vigilem::Evdev::KeyMapCache.default_filename = nil
+          pth = File.join(Bundler.root, 'data', test_name)
+          FileUtils.remove(pth) if File.exists?(pth)
+        end
+      end
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+event_files = Dir["/dev/input/event*"]
+
+if event_files.empty?
+  puts %q<can't find character devices in /dev/input/event*>
+  exit
+elsif not event_files.any? {|f| File.readable?(f) }
+  puts "Your user account isn't allowed to read from /dev/input/event*. please rerun as sudo"
+  exit
+end
+
+require 'bundler'
+Bundler.setup
+
+require 'timeout'
+
+require 'inline'
+
+require 'vigilem/support/core_ext/debug_puts'
+
+require 'vigilem/support/patch/ffi/pointer'
+
+require 'after_each_example_group'
+
+require 'delete_test_cache_after_group'
+
+$ver = `uname -r`.split('-').first
+
+$major = (ary = $ver.split('.')).first.to_i
+
+$minor = ary[1].to_i

data/spec/vigilem/_evdev_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+require 'vigilem/_evdev'
+
+describe Vigilem::Evdev, :clean_up_test_cache do
+  describe '#key_map' do
+    it 'loads the keymap' do
+      expect(described_class.key_map).to be_a Vigilem::Support::KeyMap
+    end
+  end
+end

data/spec/vigilem/evdev/context_filter_spec.rb

@@ -0,0 +1,114 @@
+require 'vigilem/evdev/context_filter'
+
+describe Vigilem::Evdev::ContextFilter do
+  
+  class ContextFilterHost
+    include Vigilem::Evdev::ContextFilter
+  end
+  
+  subject { ContextFilterHost.new }
+  
+  describe '::included' do
+    it 'extends Forwardable' do
+      expect(subject.class.singleton_class.included_modules).to include(Forwardable)
+    end
+  end
+  
+  describe '#last_known_state' do
+    it 'defaults to nil/UKNOWN' do
+      expect(subject.last_known_state).to be_nil
+    end
+  end
+  
+  describe '#was_on?' do
+    it 'compares ON to #last_known_state defaulting to false' do
+      expect(subject.was_on?).to be_falsey
+    end
+    
+    it 'returns true if #last_known_state == ON' do
+      subject.send(:last_known_state=, described_class::ON)
+      expect(subject.was_on?).to be_truthy
+    end
+  end
+  
+  describe '#was_off?' do
+    it 'compares OFF to #last_known_state defaulting to true' do
+      expect(subject.was_off?).to be_truthy
+    end
+    
+    it 'returns true if #last_known_state == OFF' do
+      subject.send(:last_known_state=, described_class::ON)
+      expect(subject.was_off?).to be_falsey
+    end
+  end
+  
+  describe '#on?' do
+    it 'raises error because it needs to be overridden' do
+      expect { subject.on? }.to raise_error(NotImplementedError)
+    end
+  end
+  
+  #alias_method :filtered?, :on?
+  
+  
+  describe '#off?' do
+    it 'raises error because it needs to be overridden' do
+      expect { subject.off? }.to raise_error(NotImplementedError)
+    end
+  end
+  
+  describe '#on_change' do
+    it 'updates #last_known_state' do
+      subject.on_change(described_class::ON)
+      expect(subject.last_known_state).to eql(described_class::ON)
+    end
+    
+    class FakeObserver
+      def update(type, value)
+        (@updates ||= []).concat([type, value])
+      end
+      attr_reader :updates
+    end
+    
+    it 'notifies observers' do
+      fo = FakeObserver.new
+      subject.add_observer(fo)
+      subject.on_change(described_class::ON)
+      expect(fo.updates).to eql([subject, described_class::ON])
+    end
+  end
+  
+  context 'private' do
+    describe '#last_known_state=' do
+      it 'sets #last_known_state' do
+        subject.send(:last_known_state=, described_class::ON)
+        expect(subject.last_known_state).to eql(described_class::ON)
+      end
+    end
+    
+    describe '#was_on=' do
+      it 'sets #was_on?' do
+        subject.send(:was_on=, false)
+        expect(subject.was_on?).to be_falsey
+      end
+      
+      it 'updates #last_known_state' do
+        subject.send(:was_on=, true)
+        expect(subject.last_known_state).to eql(described_class::ON)
+      end
+    end
+    
+    describe '#was_off=' do
+      it 'sets #was_off?' do
+        subject.send(:was_off=, true)
+        expect(subject.was_off?).to be_truthy
+      end
+      
+      it 'updates #last_known_state' do
+        subject.send(:was_off=, true)
+        expect(subject.last_known_state).to eql(described_class::OFF)
+      end
+    end
+  end
+  
+end