vigilem-x11 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 162ca2f1112eea4acea8fefef0cc1e0bb228d114
+  data.tar.gz: f6082f66f84e01897b736694b311a1e9e47b2e81
+SHA512:
+  metadata.gz: 37d103aab9dafff1e6e9340249521504047fc37895ac5393ae5f46cc859a35f5f45a7b9f24fc3396591dcb18e935363945a6897cf155c851732f9e2d82e1e6a5
+  data.tar.gz: 6e1a02234056c12c0ed2e521d903d054360b902c7556a0c2fe65ab4b08594727bf09aa517e199930c82a81e8003d679705791630b651da7a363ba6011064ebca

data/lib/vigilem/x11.rb

@@ -0,0 +1,69 @@
+require 'xlib'
+
+require 'vigilem/x11/display'
+
+module Vigilem
+module X11
+  
+ module_function
+  
+  # XQueryTree(Display *display, Window w, Window *root_return, 
+  #                Window *parent_return, Window **children_return, 
+  #                                   unsigned int *nchildren_return);
+  # @see    man xquerytree
+  # @param  [#to_ptr] display
+  # @param  [Integer] w
+  # @param  [Hash]
+  # @option :root_return [::FFI::Pointer<:ulong>]
+  # @option :parent_return [::FFI::Pointer<:ulong>]
+  # @option :children_return [::FFI::Pointer]
+  # @option :nchildren_return [::FFI::Pointer<:uint> || Integer]
+  # @return [Fixnum] status
+  def query_tree(display, w, opts={})
+    opts[:root_return] ||= ::FFI::MemoryPointer.new(:ulong, 1)
+    opts[:parent_return] ||=  ::FFI::MemoryPointer.new(:ulong, 1)
+    opts[:children_return] ||= ::FFI::MemoryPointer.new(:ulong)
+    opts[:nchildren_return] ||= ::FFI::MemoryPointer.new(:uint, 1)
+    
+    raise_nil_arg_error('display', display)
+    raise_nil_arg_error('w', w)
+    
+    Xlib::XQueryTree(display, w, opts[:root_return], opts[:parent_return], 
+                            opts[:children_return], opts[:nchildren_return])
+    opts[:nchildren_return] = opts[:nchildren_return].read_uint
+    opts.each do |k,v|
+      opts[k] = v.read_ulong if opts[k].respond_to? :read_ulong
+    end
+  end
+  
+  # 
+  # @param  [#to_ptr] display
+  # @param  [Integer || ::FFI::Pointer] focus_return
+  # @param  [Integer || ::FFI::Pointer] revert_to_return
+  # @return [Array<Fixnum, Integer, Fixnum>] exit_code, xwindow id, revert_to_return
+  def get_input_focus(display, focus_return, revert_to_return=nil)
+    display = Vigilem::X11::Display.wrap(display)
+    if not focus_return.is_a? ::FFI::MemoryPointer
+      fr = focus_return
+      focus_return = ::FFI::MemoryPointer.new(:int)
+      focus_return.write_int(fr)
+    end
+    if not revert_to_return.is_a? ::FFI::MemoryPointer
+      rtr = revert_to_return
+      revert_to_return = ::FFI::MemoryPointer.new(:int)
+      revert_to_return.write_int(rtr || 0)
+    end
+    raise_nil_arg_error('display', display)
+    raise_nil_arg_error('focus_return', focus_return)
+    [Xlib.XGetInputFocus(display, focus_return, revert_to_return), 
+                        focus_return.read_int, revert_to_return.read_int]
+  end
+  
+  def raise_nil_arg_error(name, val)
+    raise ArgumentError, "#{name} is #{val.inspect}" if val.nil?
+  end
+end
+end
+
+
+require 'vigilem/x11/input_system_handler'

data/lib/vigilem/x11/constants.rb

@@ -0,0 +1,5 @@
+module Vigilem
+module X11
+  NotifyNonlinearVirtual = 4
+end
+end

data/lib/vigilem/x11/display.rb

@@ -0,0 +1,53 @@
+require 'xlib'
+
+module Vigilem
+module X11
+  # 
+  # 
+  class Display < Xlib::Display
+    
+    @layout = superclass.layout
+    
+    # 
+    # @param [Display || FFI::Pointer || String] 
+    #          display_pointer_or_name
+    def initialize(display_pointer_or_name)
+      if display_pointer_or_name.is_a? ::FFI::Pointer
+        super(display_pointer_or_name)
+      else
+        super(Xlib.XOpenDisplay(display_pointer_or_name))
+      end
+    end
+    
+    # 
+    # @return [Fixnum]
+    def fileno
+      @fileno ||= self[:fd]
+    end
+    
+    # 
+    # @return [UNIXSocket]
+    def to_io
+      @io ||= UNIXSocket.for_fd(fileno)
+    end
+    
+    class << self
+      alias_method :open, :new
+      
+      # 
+      # @param  [Display || FFI::Pointer || String] 
+      #           display_obj_pointer_or_name
+      # @return [Display]
+      def wrap(display_obj_pointer_or_name)
+        if display_obj_pointer_or_name.is_a? self
+          display_obj_pointer_or_name
+        else
+          Display.open(display_obj_pointer_or_name)
+        end
+      end
+      
+    end
+  end
+  
+end
+end

data/lib/vigilem/x11/event_queue.rb

@@ -0,0 +1,152 @@
+require 'xlib'
+
+require 'vigilem/support/obj_space'
+
+require 'vigilem/core/buffer'
+
+require 'vigilem/core/eventable'
+
+require 'vigilem/x11/display'
+
+module Vigilem
+module X11
+  # 
+  # 
+  class EventQueue
+    
+    include Core::Buffer
+    
+    attr_reader :display
+    
+    extend Support::ObjSpace
+    
+    class << self
+      # 
+      # @param [String || Display || ::FFI::Pointer] 
+      #          display_pointer_or_name
+      def new(display_obj_pointer_or_name)
+        ret = obj_register(super(display_obj_pointer_or_name))
+        same_display_check!
+        ret
+      end
+      
+      # 
+      # finds an existing EventQueue with the given display or
+      # returns a new one based on the items passed in
+      # @param  [Display || FFI::Pointer || String] 
+      #           display_obj_pointer_or_name
+      # @return [EventQueue]
+      def acquire(display_obj_pointer_or_name)
+        dip = Display.wrap(display_obj_pointer_or_name)
+        eventq = all.find {|evq| evq.fileno == dip.fileno }
+        
+        eventq || new(dip)
+      end
+      
+      # 
+      # @return [Array]
+      def same_display_check
+        all.group_by {|ev| ev.display.fileno }.select {|k, v| v.size > 1 }
+      end
+      
+      # 
+      # @param  [StandardError] err_type, defaults to ArgumentError
+      # @raise  "EventQueues should not have the same display `#{array of event queues with same display}'"
+      # @return [NilClass]
+      def same_display_check!(err_type=ArgumentError)
+        unless (dups = same_display_check).empty?
+          raise err_type, "EventQueues should not have the same display `#{dups}'"
+        end
+      end
+      
+    end
+    
+    # 
+    # @param  [String || Display || ::FFI::Pointer] 
+    #           display_pointer_or_name
+    def initialize(display_obj_pointer_or_name)
+      @display = Display.wrap(display_obj_pointer_or_name)
+    end
+    
+    # the XPending and items pulled from the queue that
+    # haven't propagated
+    # @return [Fixnum]
+    def pending
+      pending! + _internal_buffer.size
+    end
+    
+    # only the number of events returned by XPending
+    # @return [Fixnum]
+    def pending!
+      Xlib.XPending(display!)
+    end
+    
+    # 
+    # @return [Xlib::XEvent]
+    def next_event
+      x_event = Xlib::XEvent.new
+      Xlib.XNextEvent(display!, x_event)
+      x_event
+    end
+    
+    # 
+    # @return [Fixnum]
+    def fileno
+      @fileno ||= display.fileno
+    end
+    
+    # 
+    # @raise  [ArgumentError]
+    # @return 
+    def display!
+      # a way to validate the pointer to prevent segfault?
+      if display.is_a?(::FFI::Pointer) or display.respond_to?(:to_ptr)
+        display
+      else
+        raise ArgumentError, "Display is a `#{display.inspect}'" + 
+                            "and doesn't respond to :to_ptr"
+      end
+    end
+    
+    # 
+    # @param  [Integer || Range] start_idx_range
+    # @param  [Integer] len
+    # @return [Array]
+    def slice!(start_idx_range, len=nil)
+      # this isn;t the most efficient way, but is the
+      # most straight forward
+      pending!.times.map do
+        next_event
+      end.compact.slice!(start_idx_range, *len)
+    end
+    
+    # 
+    # @raise  [NotImplemented]
+    def concat(*args)
+      raise NotImplementedError
+    end
+    
+    # 
+    # @raise  [NotImplemented]
+    def peek
+      raise NotImplementedError
+      # @todo
+      #if _internal_buffer.size > 0
+      #  _internal_buffer[0]
+      #else
+      #  if pending! > 0
+      #    next_event
+      #  end
+      #end
+    end
+    
+   private
+    # 
+    # @return [Array]
+    def _internal_buffer
+      @internal_buffer ||= []
+    end
+    
+  end
+end
+end

data/lib/vigilem/x11/input_system_handler.rb

@@ -0,0 +1,75 @@
+require 'vigilem/x11'
+
+require 'vigilem/core/input_system_handler'
+
+require 'vigilem/x11/constants'
+
+require 'vigilem/x11/display'
+
+require 'vigilem/x11/event_queue'
+
+module Vigilem
+module X11
+  # 
+  # 
+  class InputSystemHandler
+    include Core::InputSystemHandler
+    
+    attr_reader :window_xid, :demultiplexer
+    
+    # 
+    # @param  [Integer] win_xid
+    # @param  [String || Display || ::FFI::Pointer] display_pointer_or_name
+    # @param  [Integer] event_mask
+    def initialize(win_xid, display_obj_pointer_or_name, event_mask=nil)
+      
+      initialize_input_system_handler
+      
+      display = Display.open(display_obj_pointer_or_name)
+      
+      @demultiplexer = Core::Demultiplexer.acquire(EventQueue.new(display), [[self.buffer, {:func => :concat}]]) do |dem| 
+        dem.input.respond.fileno == display.fileno
+      end
+      
+      @window_xid = win_xid
+      
+      self.select_input(event_mask) if event_mask
+      
+    end
+    
+    include Core::Eventable
+    
+    # 
+    # @param  [Fixnum] num
+    # @return [Array]
+    def read_many_nonblock(num=1)
+      synchronize {
+        demultiplexer.demux(num)
+        buffer.slice!(0, num)
+      }
+    end
+    
+    # @todo   handle `X Error of failed request:  BadWindow (invalid Window parameter)'
+    # @param  [Fixnum] 
+    # @return [Fixnum] 
+    def select_input(event_mask)
+      Xlib.XSelectInput(demultiplexer.input.display, window_xid, event_mask)
+    end
+    
+    def_delegators :'demultiplexer.input', :pending, :display
+    
+    # @see    http://www.unix.com/man-page/All/3x/XGetInputFocus/
+    # @return [Array<Integer, Fixnum>] [xwindow_id, revert_to_return]
+    def get_input_focus
+      X11.get_input_focus(display, window_xid, 0)[1..-1]
+    end
+    
+    # @see    ::query_tree
+    # @return [Hash] 
+    def query_tree(opts={})
+      X11.query_tree(display, window_xid, opts)
+    end
+    
+  end
+end
+end

data/lib/vigilem/x11/system.rb

@@ -0,0 +1,37 @@
+module Vigilem
+module X11
+  module System
+    # gets the 
+    # @param  [Integer] pid
+    # @return [Integer || NilClass]
+    def ppid_of(pid)
+      to_i!(`ps -p #{pid} -o ppid= 2>&1`.strip)
+    end
+    
+    # 
+    # @param  [Intger] pid
+    # @return [File]
+    def environ_file(pid='self')
+      file_path = "#{File::SEPARATOR}#{File.join('proc', pid.to_s, 'environ')}"
+      if test ?e, file_path
+        @environ = File.open(file_path)
+      end
+    end
+    
+    # like #to_i but returns nil if not convertable
+    # @todo   move to support/core_ext
+    # @param  [String] str
+    # @return [Integer || NilClass]
+    def to_i!(str)
+      if str =~ /^\s*(0+|(0*\.0+))\s*$/
+        0
+      else
+        [str.to_i].find {|i| i != 0 }
+      end
+    end
+    
+    extend self
+    
+  end
+end
+end

data/lib/vigilem/x11/terminal_window_utils.rb

@@ -0,0 +1,33 @@
+require 'vigilem/x11/system'
+
+module Vigilem
+module X11
+  # 
+  # 
+  module TerminalWindowUtils
+   
+   extend System
+   
+   module_function
+    
+    # gets the id of the window that spawned this 
+    # ruby process
+    # @return [Integer]
+    def window_id
+      return (env = to_i!(ENV['WINDOWID'])) if env
+      
+      curr_pid = Process.pid
+      until curr_pid.to_i < 2
+        file = environ_file(curr_pid)
+        if file and (xid = to_i!(file.read.scan(/(?<=WINDOWID=)\d+/)[0]))
+          return xid
+        else
+          curr_pid = ppid_of(curr_pid)
+        end
+      end
+      
+    end
+    
+  end
+end
+end

data/lib/vigilem/x11/version.rb

@@ -0,0 +1,5 @@
+module Vigilem
+module X11
+  VERSION = '0.0.3'
+end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'xlib'
+
+require 'vigilem/support/core_ext/debug_puts'

data/spec/vigilem/x11/display_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+require 'vigilem/x11/display'
+
+describe Vigilem::X11::Display do
+  
+  after(:each) do
+    [described_class].each do |klass|
+      (klass.instance_variables - [:@layout]).each do |ivar|
+        klass.send(:remove_instance_variable, ivar)
+      end
+    end
+  end
+  
+  it 'is a subclass of Xlib::Display' do
+    expect(described_class).to be < Xlib::Display
+  end
+  
+  it 'has the same structure as Xlib::Display' do
+    expect(described_class.layout).to eql(Xlib::Display.layout)
+  end
+  
+  describe '#initialize' do
+     it 'takes a pointer and creates a display from it' do
+       expect do 
+         described_class.new(Xlib.XOpenDisplay(ENV['DISPLAY'])) 
+      end.not_to raise_error and be_a described_class
+     end
+     
+     it 'takes a display name and creates a Display' do
+       expect do 
+         described_class.new(ENV['DISPLAY']) 
+      end.not_to raise_error and be_a described_class
+     end
+  end
+  
+  context 'post_init' do
+    subject { described_class.new(ENV['DISPLAY']) }
+    
+    describe '#fileno' do
+      it 'returns the fileno of the associated IO' do
+        expect(subject.fileno).to be_an Integer
+      end
+    end
+    
+    describe '#to_io' do
+      it 'returns the display as IO' do
+        expect(subject.to_io).to be_a IO
+      end
+    end
+  end
+  
+  describe '::wrap' do
+    it 'returns a new display object' do
+      expect { described_class.wrap(ENV['DISPLAY']) }.not_to raise_error and be_a Display
+    end
+    
+    it 'takes a pointer and creates a display from it' do
+      expect { described_class.wrap(Xlib.XOpenDisplay(ENV['DISPLAY'])) }.not_to raise_error and be_a Display
+    end
+    
+    it 'takes a Display object and returns the same Display object' do
+      dpy = described_class.wrap(ENV['DISPLAY'])
+      expect { described_class.wrap(dpy) }.not_to raise_error and eql(dpy)
+    end
+  end
+  
+  #describe '::open' do
+  #  
+  #end
+  
+end

data/spec/vigilem/x11/event_queue_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+require 'vigilem/x11/event_queue'
+
+describe Vigilem::X11::EventQueue do
+  
+  let(:dpy) { Vigilem::X11::Display.new(ENV['DISPLAY']) }
+  
+  after(:each) do
+    [described_class, Vigilem::X11::Display].each do |klass|
+      (klass.instance_variables - [:@layout]).each do |ivar|
+        klass.send(:remove_instance_variable, ivar)
+      end
+    end
+  end
+  
+  describe '::same_display_check' do
+    
+    it %q<checks the ::all for EventQueue's that have the same fileno> do
+      ary = [double("EventQueue1", :display => dpy), double("EventQueue2", :display => dpy)]
+      described_class.all.concat(ary)
+      expect(described_class.same_display_check).to eql({ dpy.fileno => ary })
+    end
+    
+  end
+  
+  describe '::same_display_check!' do
+    
+    it %q<checks the ::all for EventQueue's that have the same fileno and raises an Error if some exist> do
+      ary = [double("EventQueue1", :display => dpy), double("EventQueue2", :display => dpy)]
+      described_class.all.concat(ary)
+      expect { described_class.same_display_check! }.to raise_error(ArgumentError)
+    end
+    
+  end
+  
+  describe '#initialize' do
+    it 'accepts a display obj' do
+      expect do
+        described_class.new(dpy)
+      end.to_not raise_error and be_a described_class
+    end
+    
+    it 'accepts a display pointer' do
+      expect do 
+        described_class.new(Xlib.XOpenDisplay(ENV['DISPLAY']))
+      end.to_not raise_error and be_a described_class
+    end
+    
+    it 'accepts a display_name' do
+      expect do 
+        described_class.new(ENV['DISPLAY'])
+      end.to_not raise_error and be_a described_class
+    end
+    
+  end
+  
+  describe '::new' do
+    it 'adds the instance to ' do
+      dpy = described_class.new(ENV['DISPLAY'])
+      expect(described_class.all).to include(dpy)
+    end
+    
+    it 'calls #same_display_check!' do
+      ary = [double("EventQueue1", :display => dpy), double("EventQueue2", :display => dpy)]
+      described_class.all.concat(ary)
+      expect { described_class.new(dpy) }.to raise_error(ArgumentError)
+    end
+  end
+  
+  describe '::acquire' do
+    it 'returns a new instance if none is found' do
+      described_class.all.replace([])
+      dspy = Vigilem::X11::Display.new(ENV['DISPLAY'])
+      expect(described_class.acquire(dspy)).to be_a described_class
+    end
+    
+    it 'returns the instance that has the same display#fileno' do
+      evq = described_class.new(dpy)
+      expect(described_class.acquire(dpy)).to eql(evq)
+    end
+  end
+  
+  describe '#pending!' do
+    it 'gets the XPending value' do
+      evq = described_class.new(dpy)
+      num = 1
+      allow(Xlib).to receive(:XPending) { num }
+      expect(evq.pending!).to eql(num)
+    end
+  end
+  
+  describe '#pending' do
+    it 'gets the XPending value and the size of the array not yet propagated' do
+      evq = described_class.new(dpy)
+      internal_buf = [Xlib::XEvent.new, Xlib::XEvent.new]
+      evq.send(:_internal_buffer).concat(internal_buf)
+      xpend_ret = 1
+      allow(Xlib).to receive(:XPending) { xpend_ret }
+      expect(evq.pending).to eql(xpend_ret + internal_buf.size)
+    end
+  end
+  
+  describe '#next_event' do
+    it 'gets the next event from the xwindow event queue' do
+      allow(Xlib).to receive(:XNextEvent)
+      evq = described_class.new(dpy)
+      expect(evq.next_event).to be_a Xlib::XEvent
+    end
+  end
+  
+  describe '#fileno' do
+    it 'gets the fileno of the display' do
+      evq = described_class.new(dpy)
+      expect(evq.fileno).to eql(evq.fileno)
+    end
+  end
+  
+  describe '#slice!' do
+    it 'will get the ' do
+      evq = described_class.new(dpy)
+      allow(evq).to receive(:pending!) { 1 }
+      empty_event = Xlib::XEvent.new
+      allow(evq).to receive(:next_event) { empty_event }
+      expect(evq.slice!(0)).to eql(empty_event)
+    end
+  end
+  
+  describe '#concat' do
+    it 'will error, not implemented' do
+      evq = described_class.new(dpy)
+      expect { evq.concat }.to raise_error(NotImplementedError)
+    end
+  end
+  
+  describe '#peek' do
+    it 'will error, no implemented' do
+      evq = described_class.new(dpy)
+      expect { evq.concat }.to raise_error(NotImplementedError)
+    end
+  end
+  
+  context 'private' do
+    describe '#_internal_buffer' do
+      it 'defaults to an empty array' do
+        evq = described_class.new(dpy)
+        expect(evq.send(:_internal_buffer)).to eql([])
+      end
+    end
+  end
+  
+end

data/spec/vigilem/x11/input_system_handler_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+require 'vigilem/x11/input_system_handler'
+
+describe Vigilem::X11::InputSystemHandler do
+  
+  subject { described_class.new(0x12123, (ENV['DISPLAY'] || ::FFI::MemoryPointer.new(:long, 296))) }
+  
+  after(:each) do
+    [described_class, Vigilem::X11::EventQueue, Vigilem::Core::Demultiplexer, Vigilem::X11::Display].each do |klass|
+      (klass.instance_variables - [:@layout]).each do |ivar|
+        klass.send(:remove_instance_variable, ivar)
+      end
+    end
+  end
+  
+  describe '#select_input' do
+    it 'calls XSelectInput' do
+      mask = Xlib::KeyPressMask | Xlib::FocusChangeMask
+      allow(Xlib).to receive(:XSelectInput).with(mask)
+      expect(Xlib).to receive(:XSelectInput).with(subject.demultiplexer.input.display, subject.window_xid, mask)
+      subject.select_input(mask)
+    end
+  end
+  
+  describe '#initialize' do
+    
+    it 'sets up the window if the window_xid was given' do
+      expect(subject.window_xid).to be_an Integer
+    end
+    
+    it 'calls XSelectInput if passed in' do
+      mask = Xlib::KeyPressMask | Xlib::FocusChangeMask
+      allow(Xlib).to receive(:XSelectInput).with(mask)
+      expect(Xlib).to receive(:XSelectInput)
+      Vigilem::X11::EventQueue.all.replace([])
+      described_class.new(0x1111, ::FFI::MemoryPointer.new(:long, 296), mask)
+    end
+  end
+  
+  describe '#read_many_nonblock' do
+    it 'reads a max number of events from the event_queue' do
+      allow(subject.demultiplexer.input).to receive(:shift) { [1,2,3] }
+      expect(subject.read_many_nonblock(3)).to eql([1,2,3])
+    end
+    
+    it 'calls #synchronize' do
+      allow(subject.demultiplexer.input).to receive(:shift) { [1,2,3] }
+      expect(subject).to receive(:synchronize)
+      subject.read_many_nonblock(3)
+    end
+    
+    it 'sets up the other eventable methods' do
+      allow(subject.demultiplexer.input).to receive(:shift) { [1] }
+      expect { subject.read_one_nonblock }.not_to raise_error and eql([1])
+    end
+  end
+  
+  describe '#get_input_focus' do
+    it 'calls ::get_input_focus' do
+      allow(Vigilem::X11).to receive(:get_input_focus)
+      expect(Vigilem::X11).to receive(:get_input_focus).with(subject.display, subject.window_xid, 0) { [1,2,3] }
+      subject.get_input_focus
+    end
+    
+    if Xlib.available?
+      it 'returns a Fixnum, and Integer' do
+        allow(described_class).to receive(:get_input_focus).and_call_original
+        expect(subject.get_input_focus).to match [a_kind_of(Fixnum), a_kind_of(Integer)]
+      end
+    end
+  end
+  
+end

data/spec/vigilem/x11/system_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+require 'vigilem/x11/system'
+
+describe Vigilem::X11::System do
+  
+  describe '::to_i!' do
+    it 'returns an Integer if convertable' do
+      expect(described_class.to_i!("1234.1234")).to eql(1234)
+    end
+    
+    it 'returns an nil if not convertable' do
+      expect(described_class.to_i!("Sjaldan er ein baran stok")).to be_nil
+    end
+    
+    it 'returns 0 when the value is zero' do
+      expect(described_class.to_i!("0")).to eql(0)
+    end
+    
+    it 'returns 0 when the value is zero equivilant' do
+      expect(described_class.to_i!(".00")).to eql(0)
+    end
+    
+    it %q<doesn't return 0 if it contains zero> do
+      expect(described_class.to_i!('83886092')).to eql(83886092)
+    end
+  end
+  
+  describe '::environ_file' do
+    it 'defaults to the /proc/self/environ' do
+      expect(described_class.environ_file.path).to eql("/proc/self/environ")
+    end
+    
+    it 'gets the environ file of the pid passed in' do
+      expect(described_class.environ_file(Process.pid).path).to eql("/proc/#{Process.pid}/environ")
+    end
+  end
+  
+  describe '::ppid_of' do
+    it 'gets the ppid of the passed in pid' do
+      expect(described_class.ppid_of(Process.pid)).to eql(Process.ppid)
+    end
+    
+    it 'returns nil if ppid cannot be found' do
+      expect(described_class.ppid_of(`cat /proc/sys/kernel/pid_max`.to_i + 1)).to be_nil
+    end
+  end
+  
+end

data/spec/vigilem/x11/terminal_window_utils_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+require 'tempfile'
+
+require 'vigilem/x11/terminal_window_utils'
+
+describe Vigilem::X11::TerminalWindowUtils do
+  
+  describe '::window_id' do
+    it 'returns the id of the window if it exists' do
+      expect(described_class.window_id).to be > 0
+    end
+    
+    it 'checks the environ_file if the ENV is empty' do
+    
+      ENV['WINDOWID'] = ''
+      allow(described_class).to receive(:environ_file) { Tempfile.new('asdf') }
+      expect(described_class).to receive(:environ_file)
+      described_class.window_id
+    end
+    
+    it 'returns traverses the pid tree to find an WINDOWID in the environ_file' do
+      ENV['WINDOWID'] = ''
+      allow(described_class).to receive(:environ_file) { Tempfile.new('asdf') }
+      expect(described_class.window_id).to be_nil
+    end
+    
+  end
+end

data/spec/vigilem/x11_spec.rb

@@ -0,0 +1,44 @@
+require 'vigilem/x11'
+
+describe Vigilem::X11 do
+  if Xlib.available?
+    
+    describe '::get_input_focus' do
+      
+      let(:display) { Vigilem::X11::Display.new(ENV['DISPLAY'] || ::FFI::MemoryPointer.new(:long, 296)) }
+      
+      let(:win_id) { 0x12123 }
+      
+=begin
+      # this should work, but allow strips out the arguments (or something) and 
+      # then ArgumentError: "Invalid Memory object" is raised
+      it 'calls XGetInputFocus' do
+        allow(Xlib).to receive(:XGetInputFocus).with(a_kind_of(::FFI::Struct), a_kind_of(Fixnum), a_kind_of(Fixnum))
+        expect(Xlib).to receive(:XGetInputFocus).with(a_kind_of(::FFI::Struct), a_kind_of(Fixnum), a_kind_of(Fixnum))
+        
+        subject.get_input_focus
+      end
+=end
+      it 'accepts [String],[Fixnum],[Fixnum] returns [Fixnum, Integer, Fixnum]' do
+        expect(described_class.get_input_focus(display, win_id)).to match [
+          a_kind_of(Fixnum), a_kind_of(Integer), a_kind_of(Fixnum)
+        ]
+      end
+      
+      it 'updates window ptr' do
+        window = FFI::MemoryPointer.new(:ulong)
+        window.write_ulong(win_id)
+        described_class.get_input_focus(display, window)
+        expect(window.read_int).not_to eql(win_id)
+      end
+      
+      it 'updates revert_to_return ptr' do
+        revert_to_return = FFI::MemoryPointer.new(:int)
+        revert_to_return.write_int(0)
+        described_class.get_input_focus(display, win_id)
+        expect(revert_to_return.read_int).to be_a Fixnum
+      end
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification
+name: vigilem-x11
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- jtzero
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vigilem-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: turnip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: X11 bindings for Vigilem, currently used internally only
+email:
+- jtzero511@gmail
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/vigilem/x11.rb
+- lib/vigilem/x11/constants.rb
+- lib/vigilem/x11/display.rb
+- lib/vigilem/x11/event_queue.rb
+- lib/vigilem/x11/input_system_handler.rb
+- lib/vigilem/x11/system.rb
+- lib/vigilem/x11/terminal_window_utils.rb
+- lib/vigilem/x11/version.rb
+- spec/spec_helper.rb
+- spec/vigilem/x11/display_spec.rb
+- spec/vigilem/x11/event_queue_spec.rb
+- spec/vigilem/x11/input_system_handler_spec.rb
+- spec/vigilem/x11/system_spec.rb
+- spec/vigilem/x11/terminal_window_utils_spec.rb
+- spec/vigilem/x11_spec.rb
+homepage: http://rubygems.org/gems/vigilem-x11
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: X11 bindings for Vigilem
+test_files:
+- spec/spec_helper.rb
+- spec/vigilem/x11/display_spec.rb
+- spec/vigilem/x11/event_queue_spec.rb
+- spec/vigilem/x11/input_system_handler_spec.rb
+- spec/vigilem/x11/system_spec.rb
+- spec/vigilem/x11/terminal_window_utils_spec.rb
+- spec/vigilem/x11_spec.rb