vigilem-win32_api 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bbde09d132a14953b05aeb4838acc918ab48c878
-  data.tar.gz: 8a9eb4816a5a373fedd2838ce1fb05eba9305d90
+  metadata.gz: 1c295f6b135c5c95f699b1e222bcdae3651023c0
+  data.tar.gz: 49a302108d91627feb7cdd3e61b814ce844371d0
 SHA512:
-  metadata.gz: 1cbfeaef82619e2b953cf1dc4da2c01756aebb4b32d41c869226e19090db8bca0af9dc8c6da2daa62bc61568bf127977efcb7fd0e889e2c79ec9a014d850c6ce
-  data.tar.gz: 8d93eaf3ee72ae910bf61d06e33ff9f69e335167c34c4d939818d59130af29f64d9bf0a09b547b624ca68cc02b121c738f8f1fcb9b99cbc29a20125e09557af8
+  metadata.gz: 6b3404c15cc87a9d3976572fc95e6992f61847a4fa52658dd54b747ff7f575e0377a4a6c3d685adc270904755b4c3727e82cac54df4211944995fddc015d602e
+  data.tar.gz: 35e5f3a42dddf3cd18393c9738bc7c1895ace37c75a97d22887b74e70b5f5dcdd566059e3056c55b98c5e4530d8aee5e7bdbefce601d8c3716f9f8c9ba7c5e60

data/lib/vigilem/win32_api/input_system_handler.rb

@@ -96,7 +96,7 @@ module Win32API
     # @param  [Array] msgs
     # @return 
     def demux(*msgs)
-      hub.demux(self, *msgs)
+      hub.demux(self.buffer, *msgs)
     end
    private
     

data/lib/vigilem/win32_api/utils/keyboard.rb

@@ -51,7 +51,7 @@ module Keyboard
     # @param  dw_state_names
     # @return [TrueClass || FalseClass]
     def nav_control_key?(virtual_key, *dw_state_names)
-      (control_key?(virtual_key) or virtual_key == Keyboard::VK[:CLEAR]) and dw_state_names.include?(:ENHANCED_KEY)
+      (control_pad_key?(virtual_key) or virtual_key == Keyboard::VK[:CLEAR]) and dw_state_names.include?(:ENHANCED_KEY)
     end
   end
   

data/lib/vigilem/win32_api/version.rb

@@ -1,5 +1,5 @@
 module Vigilem
 module Win32API
-  VERSION = '0.0.10'
+  VERSION = '0.0.11'
 end
 end

data/lib/vigilem/win32_api.rb

@@ -1,6 +1,7 @@
 require 'ffi'
 
 require 'vigilem/win32_api/constants'
+require 'vigilem/win32_api/virtual_keys/map'
 
 require 'vigilem/win32_api/types'
 require 'vigilem/win32_api/console_input_events'
@@ -10,48 +11,54 @@ require 'vigilem/win32_api/p_input__record'
 
 module Vigilem
 
-# @see    http://msdn.microsoft.com for usage
-# @todo   consider FFI options Hash :blocking (Boolean) — default: @blocking — set to true if the C function is a blocking call
-module Win32API
-  extend ::FFI::Library
-  
-  ffi_lib 'kernel32', 'user32'
-  ffi_convention :stdcall
-  
-  attach_function :GetStdHandle, [:DWORD], :HANDLE
-  
-  attach_function :MapVirtualKeyW, [:UINT, :UINT], :UINT
-  
- module_function
-  
-  def PeekConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
-    _PeekConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+  # @see    http://msdn.microsoft.com for usage
+  # @todo   consider FFI options Hash :blocking (Boolean) — default: @blocking — set to true if the C function is a blocking call
+  module Win32API
+    include Constants
+    
+    VirtualKeys::Map.invert.each do |vk_name, int|
+      const_set(vk_name, int)
+    end
+    
+    extend ::FFI::Library
+    
+    ffi_lib 'kernel32', 'user32'
+    ffi_convention :stdcall
+    
+    attach_function :GetStdHandle, [:DWORD], :HANDLE
+    
+    attach_function :MapVirtualKeyW, [:UINT, :UINT], :UINT
+    
+   module_function
+    
+    def PeekConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+      _PeekConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+    end
+    
+    def ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+      _ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+    end
+    
+    def ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+      _ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+    end
+    
+    def WriteConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+      _WriteConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
+    end
+    
+   private
+    
+    attach_function :_PeekConsoleInputW, :PeekConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
+    
+    attach_function :_ReadConsoleInputW, :ReadConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
+    
+    attach_function :_ReadConsoleInputW, :ReadConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
+    
+    # future use
+    attach_function :_WriteConsoleInputW, :WriteConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
+    
   end
-  
-  def ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
-    _ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
-  end
-  
-  def ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
-    _ReadConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
-  end
-  
-  def WriteConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
-    _WriteConsoleInputW(hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead)
-  end
-  
- private
-  
-  attach_function :_PeekConsoleInputW, :PeekConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
-  
-  attach_function :_ReadConsoleInputW, :ReadConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
-  
-  attach_function :_ReadConsoleInputW, :ReadConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
-  
-  # future use
-  attach_function :_WriteConsoleInputW, :WriteConsoleInputW, [:HANDLE, :PINPUT_RECORD, :DWORD, :pointer], :BOOL
-  
-end
 end
 
 require 'vigilem/win32_api/rubyized'

data/spec/spec_helper.rb

@@ -8,12 +8,14 @@ require 'timeout'
 
 require 'vigilem/support/core_ext/debug_puts'
 
+require 'vigilem/support/patch/ffi/pointer'
+
 require 'attributes_and_size_test'
 
 require 'input_helper'
 
 =begin
-#to discover when tests hang which will happen because I have not correctly isolated the tests
+#to discover when tests hang, which will happen because I have not correctly isolated the tests
 # also can use rspec -f d
 RSpec.configure do |config|
   

data/spec/vigilem/win32_api/eventable_spec.rb

@@ -1,4 +1,10 @@
-require 'timeout'
+require 'spec_helper'
+
+require 'vigilem/win32_api/eventable'
+
+require 'vigilem/win32_api/input_system_handler'
+
+require 'vigilem/core/adapters/adapter'
 
 describe Vigilem::Win32API::Eventable do
   
@@ -92,5 +98,37 @@ describe Vigilem::Win32API::Eventable do
         end
       end.to raise_error(Timeout::Error)
     end
+    
+    context 'event_loop' do
+      
+      let(:eventable_adapter) do
+        input_sys = double('InputSystem', :GetStdHandle => 3)
+        @incr = 0
+        allow(input_sys).to receive(:PeekConsoleInputW) do |hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead|
+          if @incr == 0
+            lpBuffer.replace(Vigilem::Win32API::PINPUT_RECORD.new(3, 
+              Vigilem::Win32API::INPUT_RECORD[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97}, 32]}]
+            ))
+            @incr += 1
+          end
+          1
+        end
+        allow(input_sys).to receive(:ReadConsoleInputW) do |hConsoleInput, lpBuffer, nLength, lpNumberOfEventsRead|
+          lpBuffer.replace(Vigilem::Win32API::PINPUT_RECORD.new(3, 
+            Vigilem::Win32API::INPUT_RECORD[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97}, 32]}]
+          ))
+          1
+        end
+        EventableAdapter.new(Vigilem::Win32API::InputSystemHandler.new(input_sys))
+      end
+      
+      it 'will return one event per event in the win32 event queue' do # to check that there is parity between the input_system and here
+        expect([eventable_adapter.read_one_nonblock, eventable_adapter.read_one_nonblock]).to match [
+          instance_of(Vigilem::Win32API::INPUT_RECORD), nil
+        ]
+      end
+    end
+    
   end
+  
 end

data/spec/vigilem/win32_api/input_system_handler_spec.rb

@@ -4,6 +4,35 @@ require 'vigilem/win32_api/input_system_handler'
 
 describe Vigilem::Win32API::InputSystemHandler do
   
+  after(:each) do
+    Vigilem::Core::Hub.all.clear
+  end
+  
+  describe '#hub' do
+    it 'returns a hub' do
+      expect(subject.hub).to match instance_of(Vigilem::Core::Hub)
+    end
+    
+    it 'returns a hub that this buffer is attached to' do
+      expect(subject.hub.buffers).to match a_collection_including(subject.buffer)
+    end
+  end
+  
+  describe '#demux' do
+    
+    it 'demultiplexs events to other observers' do
+      subject.hub << (another_buffer = [])
+      subject.demux(*%w(a b c))
+      expect(another_buffer).to include(*%w(a b c))
+    end
+    
+    it 'does not demultiplex to this buffer' do
+      subject.hub << (another_buffer = [])
+      subject.demux(*%w(a b c))
+      expect(subject.buffer).to be_empty
+    end
+  end
+  
   describe '#GetStdHandle' do
     
     it 'forwards the call to the underlying system' do
@@ -68,6 +97,16 @@ describe Vigilem::Win32API::InputSystemHandler do
       end
     end
     context 'buffer > length' do
+      
+      let(:args) do 
+        {
+          :hConsoleInput => Vigilem::Win32API.GetStdHandle(Vigilem::Win32API::STD_INPUT_HANDLE),
+          :lpBuffer => Vigilem::Win32API::PINPUT_RECORD.new(len = 1),
+          :nLength => len,
+          :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
+        }
+      end
+      
       let(:input_record) { Vigilem::Win32API::INPUT_RECORD[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97}, 32]}] }
       let!(:input_system) do
         subject.buffer.concat(3.times.map { input_record.dup })
@@ -79,15 +118,6 @@ describe Vigilem::Win32API::InputSystemHandler do
         subject
       end
       
-      let(:args) do 
-        {
-          :hConsoleInput => Vigilem::Win32API.GetStdHandle(Vigilem::Win32API::STD_INPUT_HANDLE),
-          :lpBuffer => Vigilem::Win32API::PINPUT_RECORD.new(len = 1),
-          :nLength => len,
-          :lpNumberOfEventsRead => FFI::MemoryPointer.new(:dword, 1)
-        }
-      end
-      
       it 'checks the buffer first then call the system' do
         expect(subject).to receive(:buffer).and_call_original
         subject.PeekConsoleInput(*args.values)
@@ -103,7 +133,8 @@ describe Vigilem::Win32API::InputSystemHandler do
   
   describe '#ReadConsoleInput' do
     context 'empty buffer' do
-      let(:args) do 
+      
+      let(:args) do
         {
           :hConsoleInput => Vigilem::Win32API.GetStdHandle(Vigilem::Win32API::STD_INPUT_HANDLE),
           :lpBuffer => Vigilem::Win32API::PINPUT_RECORD.new(len = 3),
@@ -114,21 +145,31 @@ describe Vigilem::Win32API::InputSystemHandler do
       
       let(:input_record) { Vigilem::Win32API::INPUT_RECORD[Vigilem::Win32API::KEY_EVENT, {:KeyEvent => [1, 1, 70, 33, {:UnicodeChar => 97}, 32]}] }
       
-      let!(:input_system) do
-        lnk = spy(subject.send(:link), :semaphore => @monitor ||= Monitor.new)
-        subject.send(:link=, lnk)
-        allow(subject).to receive(:buffer).and_call_original
-        allow(subject).to receive(:ReadConsoleInput).and_call_original
-        subject.ReadConsoleInput(*args.values)
-        subject
+      subject do
+        lnk = double('Vigilem::Win32API', :semaphore => @monitor ||= Monitor.new)
+        allow(lnk).to receive(:ReadConsoleInputW) do 
+          args[:lpBuffer].replace([input_record])
+          1
+        end
+        sub = described_class.new(lnk)
+        allow(sub).to receive(:buffer).and_call_original
+        allow(sub).to receive(:ReadConsoleInput).and_call_original
+        sub.ReadConsoleInput(*args.values)
+        sub
       end
       
+      before(:each) { subject }
+      
       it 'checks the buffer first' do
-        expect(input_system).to have_received(:buffer).at_least(:once)
+        expect(subject).to have_received(:buffer).at_least(:once)
       end
       
       it 'calls the link#ReadConsoleInput' do
-        expect(input_system.send(:link)).to have_received(:ReadConsoleInputW).at_least(:once)
+        expect(subject.send(:link)).to have_received(:ReadConsoleInputW).at_least(:once)
+      end
+      
+      it 'updates the lpBuffer' do
+        expect(args[:lpBuffer].size).to eql(1)
       end
     end
     
@@ -161,4 +202,37 @@ describe Vigilem::Win32API::InputSystemHandler do
     
   end
   
+  describe '#MapVirtualKey' do
+    
+    let(:input_system) do
+      dbl = double('InputSystem')
+      allow(dbl).to receive(:MapVirtualKeyW)
+    end
+    
+    subject do
+      sub = described_class.new(input_system)
+      allow(sub).to receive(:buffer).and_call_original
+      allow(sub).to receive(:MapVirtualKey).and_call_original
+      sub
+    end
+    
+    it 'calls the underlying #MapVirtualKeyW on the input_system' do
+      expect(input_system).to receive(:MapVirtualKeyW)
+      subject.MapVirtualKey(Vigilem::Win32API::VK_LSHIFT, Vigilem::Win32API::MAPVK_VK_TO_VSC)
+    end
+    
+    it 'raises an ArgumentError if uCode is not an Integer' do
+      expect do 
+        subject.MapVirtualKey(:VK_LSHIFT, Vigilem::Win32API::MAPVK_VK_TO_VSC)
+      end.to raise_error(ArgumentError)
+    end
+    
+    it 'raises an ArgumentError if uMapType is not an Integer' do
+      expect do 
+        subject.MapVirtualKey(Vigilem::Win32API::VK_LSHIFT, :MAPVK_VK_TO_VSC)
+      end.to raise_error(ArgumentError)
+    end
+    
+  end
+  
 end

data/spec/vigilem/win32_api/utils/keyboard_spec.rb

@@ -44,13 +44,13 @@ describe (KB = Vigilem::Win32API::Utils::Keyboard) do
       end
     end
     
-    describe '::nav_control_pad_key?' do
+    describe '::nav_control_key?' do
       it 'returns true if the key is one that is above the nav arrow pad' do
-        expect(KB.nav_control_pad_key?(KB::VK[:NEXT], :ENHANCED_KEY, :SOME_OTHER_KEY)).to be_truthy
+        expect(KB.nav_control_key?(KB::VK[:NEXT], :ENHANCED_KEY, :SOME_OTHER_KEY)).to be_truthy
       end
       
       it 'returns false if the key is one that is not above the nav arrow pad' do
-        expect(KB.nav_control_pad_key?(1, :ENHANCED_KEY)).to be_falsey
+        expect(KB.nav_control_key?(1, :ENHANCED_KEY)).to be_falsey
       end
     end
     

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vigilem-win32_api
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - jtzero
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-05 00:00:00.000000000 Z
+date: 2015-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: vigilem-dom