x_do 0.1.0

data/spec/x_do/ffi_lib_ext_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
+
+describe XDo::FFILib do
+  describe 'XDoSearch#from_options' do
+    describe 'with no flag' do
+      let(:search) do
+        XDo::FFILib::XDoSearch.from_options
+      end
+      
+      it 'should set flags to 0' do
+        search[:searchmask].should == 0
+      end
+      
+      it 'should set require to AND' do
+        search[:require].should == 1
+      end
+      
+      it 'should set maximum depth to -1' do
+        search[:max_depth].should == -1
+      end
+    end
+    
+    describe 'with a set maximum depth' do
+      let(:search) do
+        XDo::FFILib::XDoSearch.from_options :depth => 42
+      end
+      
+      it 'should not set any flags' do
+        search[:searchmask].should == 0
+      end
+
+      it 'should set field correctly' do
+        search[:max_depth].should == 42
+      end
+    end
+
+    describe 'with require set to :any' do
+      let(:search) do
+        XDo::FFILib::XDoSearch.from_options :require => :any
+      end
+      
+      it 'should not set any flags' do
+        search[:searchmask].should == 0
+      end
+
+      it 'should set require correctly' do
+        search[:require].should == 0
+      end
+    end
+
+    describe 'with 1 boolean flag' do
+      let(:search) do
+        XDo::FFILib::XDoSearch.from_options :visible => true
+      end
+      
+      it 'should set flags correctly' do
+        search[:searchmask].should == XDo::FFILib::Consts::SEARCH_ONLYVISIBLE
+      end
+
+      it 'should set fields correctly' do
+        search[:only_visible].should == 1
+      end
+    end
+
+    describe 'with 1 int flag' do
+      let(:search) do
+        XDo::FFILib::XDoSearch.from_options :screen => 42
+      end
+      
+      it 'should set flags correctly' do
+        search[:searchmask].should == XDo::FFILib::Consts::SEARCH_SCREEN
+      end
+
+      it 'should set field correctly' do
+        search[:screen].should == 42
+      end
+    end
+
+    describe 'with 1 string flag' do
+      let(:search) do
+        XDo::FFILib::XDoSearch.from_options :class => 'Normal'
+      end
+      
+      it 'should set flags correctly' do
+        search[:searchmask].should == XDo::FFILib::Consts::SEARCH_CLASS
+      end
+
+      it 'should set fields correctly' do
+        search[:winclass].get_string(0).should == 'Normal'
+      end
+    end
+    
+    describe 'with 2 string flags' do
+      let(:search) do
+        XDo::FFILib::XDoSearch.from_options :title => 'Terminal',
+                                            :name => 'gnome-terminal'
+      end
+      
+      it 'should set flags correctly' do
+        search[:searchmask].should == XDo::FFILib::Consts::SEARCH_NAME |
+                                      XDo::FFILib::Consts::SEARCH_TITLE
+      end
+
+      it 'should set fields correctly' do
+        search[:winname].get_string(0).should == 'gnome-terminal'
+        search[:title].get_string(0).should == 'Terminal'
+      end
+    end
+    
+    describe 'with mixed flags' do
+      let(:search) do
+        XDo::FFILib::XDoSearch.from_options :class_name => 'rbx', :pid => 42
+      end
+      
+      it 'should set flags correctly' do
+        search[:searchmask].should == XDo::FFILib::Consts::SEARCH_CLASSNAME |
+                                      XDo::FFILib::Consts::SEARCH_PID
+      end
+
+      it 'should set fields correctly' do
+        search[:winclassname].get_string(0).should == 'rbx'
+        search[:pid].should == 42
+      end
+    end
+  end
+end

data/spec/x_do/keyboard_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
+
+describe XDo::Keyboard do
+  let(:xdo) { XDo.new }
+  let(:keyboard) { xdo.keyboard }
+  
+  describe 'after pressing Alt+Tab' do
+    before do
+      @old_active_window = xdo.focused_window
+      keyboard.type_keysequence 'Alt_L+Tab'
+      sleep 0.1
+    end
+    after do
+      keyboard.type_keysequence 'Alt_L+Tab'
+      sleep 0.1
+    end
+    
+    it 'should switch the focused window' do
+      xdo.focused_window.should_not == @old_active_window
+    end
+  end
+  
+  describe 'after typing injected' do
+    before do
+      keyboard.type_string "injected\n"
+    end
+    
+    it 'should reflect the string in gets' do
+      $stdin.gets.should == "injected\n"
+    end
+  end
+end

data/spec/x_do/mouse_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
+
+describe XDo::Mouse do
+  let(:xdo) { XDo.new }
+  let(:mouse) { xdo.mouse }
+  
+  describe 'location' do
+    let(:location) { mouse.location }
+    
+    it 'should have 3 coordinates' do
+      location.should have(3).coordinates
+    end
+    
+    it 'should have non-negative coordinates' do
+      location[0].should >= 0
+      location[1].should >= 0
+      location[2].should >= 0
+    end
+    
+    describe 'after moving' do
+      let(:new_location) { [location[0] + 20, location[1] + 20, location[2]] }
+      before do
+        mouse.move(*new_location)
+        mouse.wait_for_move_from location[0], location[1]
+      end
+      after { mouse.move(*location) }
+      
+      it 'should change to the move arguments' do
+        mouse.location.should == new_location
+      end
+      
+      it 'should not block wait_for_move_to' do
+        lambda {
+          mouse.wait_for_move_to new_location[0], new_location[1]
+        }.should_not raise_error
+      end
+    end
+
+    describe 'after relative moving' do
+      let(:new_location) { [location[0] + 20, location[1] + 20, location[2]] }
+      before do
+        new_location
+        mouse.move_relative 20, 20
+        mouse.wait_for_move_from location[0], location[1]
+      end
+      after { mouse.move(*location) }
+      
+      it 'should change to the move arguments' do
+        mouse.location.should == new_location
+      end
+    end
+  end
+end

data/spec/x_do/window_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
+
+describe XDo::Window do
+  let(:xdo) { XDo.new }
+  let(:all) { xdo.find_windows }
+  
+  describe 'last window' do
+    let(:window) { all.last }
+    
+    it 'should == another instance with the same window id' do
+      window.should == XDo::Window.new(xdo, window._window)
+    end
+
+    it 'should hash to the same value as another instance with the same window id' do
+      window.hash.should == XDo::Window.new(xdo, window._window).hash
+    end
+    
+    it 'should not == an instance with a different id' do
+      window.should_not == XDo::Window.new(xdo, window._window + 1)
+    end
+
+    it 'should not == a string' do
+      window.should_not == "window"
+    end
+
+    it 'should not == its id' do
+      window.should_not == window._window
+    end
+  end
+  
+  describe 'active window' do
+    let(:window) { xdo.active_window }
+    it 'should have a non-zero pid' do
+      window.pid.should_not == 0
+    end
+    
+    describe 'location' do
+      let(:location) { window.location }
+      
+      it 'should have 2 coordinates' do
+        location.should have(2).coordinates
+      end
+      
+      it 'should have non-negative coordinates' do
+        location.first.should >= 0
+        location.last.should >= 0
+      end
+      
+      describe 'after moving' do
+        let(:new_location) { [location.first + 200, location.last + 200] }
+        before { window.move(*new_location) }
+        after { window.move(*location) }
+        
+        it 'should change to the move arguments' do
+          window.location.should == new_location
+        end
+      end
+    end
+
+    describe 'size' do
+      let(:size) { window.size }
+      
+      it 'should have 2 dimensions' do
+        size.should have(2).dimensions
+      end
+      
+      it 'should have positive dimensions' do
+        size.first.should > 0
+        size.last.should > 0
+      end
+      
+      describe 'after resizing' do
+        let(:new_size) { [size.first + 100, size.last + 100] }
+
+        before { window.resize(*new_size) }
+        after { window.resize(*size) }
+        
+        it 'should change to approximately the resize arguments' do
+          window.size.first.should be_within(10).of(new_size.first)
+          window.size.last.should be_within(50).of(new_size.last)
+        end
+      end
+    end
+    
+    describe 'after mouse move in window center' do
+      before do
+        @old_mouse_location = xdo.mouse.location
+        size = window.size
+        middle = [size.first / 2, size.last / 2]
+        window.move_mouse(*middle)
+      end
+      after do
+        xdo.mouse.move(*@old_mouse_location)
+      end
+      
+      it 'should have moved the mouse cursor' do
+        xdo.mouse.location.should_not == @old_mouse_location
+      end
+      
+      describe 'after right click' do
+        before do
+          @old_window_count = xdo.find_windows.length
+          window.click_mouse 3
+          sleep 0.1
+        end
+        
+        after do
+          xdo.mouse.move_relative -20, -20
+          xdo.mouse.click 1
+          sleep 0.1
+        end
+        
+        it 'should have popped up a context menu' do
+          xdo.find_windows.length.should_not == @old_window_count
+        end
+        
+        describe 'after left click outside menu' do
+          before do
+            xdo.mouse.move_relative -20, -20
+            xdo.mouse.click 3
+            sleep 0.1
+          end
+
+          it 'should have dismissed context menu' do
+            xdo.find_windows.length.should == @old_window_count
+          end
+        end
+      end
+    end
+    
+    describe 'after typing injected in the window' do
+      before do
+        window.type_string "injected\n"
+      end
+      
+      it 'should reflect the string in gets' do
+        $stdin.gets.should == "injected\n"
+      end
+    end
+  end
+end

data/tasks/ffi_codegen.rb

@@ -0,0 +1,108 @@
+require 'ffi'
+require 'ffi/tools/const_generator'
+require 'ffi/tools/struct_generator'
+require 'set'
+
+desc 'Regenerate ffi_autogen.rb'
+task :ffi_header do
+  XDo::Tasks.generate_ffi_header
+end
+
+# :nodoc: namespace
+module XDo
+  
+module Tasks
+  def self.resolve_constants(pattern, format)    
+    if FFI::Platform.mac?
+      header_path = '/System/Library/Frameworks/PCSC.framework/Headers/'
+    else
+      header_path = '/usr/include/'
+    end
+    headers = Dir.glob(header_path + 'xdo*.h').map { |f| File.basename f }
+    
+    consts = Set.new
+    headers.each do |header|
+      contents = File.read("#{header_path}#{header}")
+      contents.each_line do |line|
+        tokens = line.split
+        next unless tokens[0] == '#define'
+        next if tokens[1].index '('
+        consts << tokens[1] if pattern =~ tokens[1]
+      end
+      contents.scan /enum\s*\{([^}]*)\}/ do |match|
+        match[0].split(',').each do |enum_item|
+          enum_name = enum_item.split('=').first.strip
+          consts << enum_name if pattern =~ enum_name
+        end
+      end
+    end
+  
+    const_gen = FFI::ConstGenerator.new(nil,
+        :cppflags => "-w -I#{header_path}") do |g|  
+      headers.each { |header| g.include header }
+      consts.each { |const| g.const const, format }
+    end
+  
+    const_gen.constants
+  end
+  
+  def self.output_constants(constants, f)
+    constants.each do |name, const|
+      value = const.to_ruby
+      value += 'nil' if value.strip[-1] == ?=
+      f.write "    #{value}\n"
+    end
+  end
+  
+  def self.output_enum(enum_name, constants, name_regexp, f)
+    f.write "  #{enum_name} = enum [\n"
+    
+    re = Regexp.new('^' + name_regexp + '$')
+    constants.each do |name, const|
+      ruby_name = re.match(name)[1]
+      f.write "    :#{ruby_name.downcase}, Consts::#{name},\n"    
+    end
+  
+    f.write "  ]\n"
+  end
+
+  def self.generate_ffi_header
+    File.open('lib/x_do/ffi_autogen.rb', 'wb') do |f|
+      f.write "# Automatically generated by tasks/ffi_codegen.rb\n\n"
+      
+      # Return codes.
+      stat_consts = resolve_constants(/^XDO_.*$/, '%d')
+      # Search flags.
+      search_consts = resolve_constants(/^SEARCH_/, '0x%04X')
+      # Window sizing flags.
+      sizing_consts = resolve_constants(/^SIZE_/, '%d')
+      # Search direction.
+      direction_consts = resolve_constants(/^XDO_FIND_/, '%d')
+      
+      f.write "# :nodoc: namespace\n"
+      f.write "class XDo\n\n"
+      f.write "# :nodoc: namespace\n"
+      f.write "module FFILib\n"
+    
+      f.write "  # Constant values extracted from headers.\n"
+      f.write "  module Consts\n"
+      output_constants stat_consts, f
+      output_constants search_consts, f
+      output_constants sizing_consts, f
+      output_constants direction_consts, f
+      f.write "  end  # module XDo::FFILib::Consts\n\n"
+    
+      f.write "  # Status returned by libxdo functions.\n"
+      output_enum 'Status', stat_consts, 'XDO_(.*)', f
+      f.write "\n"
+    
+      f.write "  # Search directions.\n"
+      output_enum 'Direction', direction_consts, 'XDO_FIND_(.*)', f
+      f.write "\n"
+    
+      f.write "end  # namespace XDo::FFILib\n"
+      f.write "end  # namespace XDo\n"
+    end
+  end
+end  # namespace XDo::Tasks
+end  # namespace XDo