xdo 0.0.4

data/samples/full_demo.rb

@@ -0,0 +1,189 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+#--
+#This file is part of XDo. Copyright © 2009 by Marvin Gülker. 
+#XDo is published under Ruby's license. See http://www.ruby-lang.org/en/LICENSE.txt
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+#++
+
+=begin
+This is the full XDo demo. We will create a 
+command-line program that will be able to open 
+and close the default CD drive, open gedit and 
+type some text in tabular form and click the 
+"show desktop" button in the lower-left corner of 
+the Ubuntu desktop. Even if you don't use Ubuntu, 
+you may get the logic and find this demo useful. 
+
+Every OS and even every computer are different in their 
+user interface. If you'd like to add sample files for a 
+specific OS, feel free to contact me at sutniuq ät gmx Dot net. 
+=end
+
+#First, require all Xdo files. 
+require "xdo/clipboard"
+require "xdo/drive"
+require "xdo/keyboard"
+require "xdo/mouse"
+require "xdo/xwindow"
+
+class XXX
+  
+  def keyboard
+    #Make sure gedit is not running, since it would open 
+    #a new tab and not a new window if invoked again. 
+    raise(RuntimeError, "gedit is already running; please close it before using.") unless XDo::XWindow.search("gedit").empty?
+    #If we would use system in the main program to open 
+    #gedit, it would hang until gedit is closed. That's why 
+    #we run it in a separate process. 
+    spawn("gedit")
+    #Now we wait until gedit has made up its GUI. 
+    #wait_for_window returns the ID of the found window, so 
+    #we catch it and...
+    id = XDo::XWindow.wait_for_window("gedit")
+    #...use it to create a new reference to gedit's window. 
+    #Note that this is a pseudo reference, not a real one. 
+    #XDo allows you to create references even to unexisting 
+    #windows, so the X window manager will not recognize 
+    #the pseudo reference. You can check if the window 
+    #you're looking for exists by calling #exists? on the 
+    #XWindow object. 
+    xwin = XDo::XWindow.new(id)
+    #Now we move it 20 pixels right and 10 down. 
+    xwin.move(xwin.position[0] + 20, xwin.position[1] + 10)
+    #After having fun with it, let's do something useful. 
+    #XDo::Keyboard.simulate fakes keystrokes and recognizes 
+    #special escape sequences in braces { and }. For some 
+    #special characters like tab you can use an ASCII escape 
+    #like \t. The most special keys like [ESC] don't have 
+    #those a shortcut, so you will have to write {ESC} in 
+    #order to send them. 
+    XDo::Keyboard.simulate("This will be some test text.")
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.delete #This will send a BackSpace keypress. If you want a DEL, pass in true as a parameter. 
+    #I promised at the beginning, we were goint to create data in tabular form, 
+    #so here it is: 
+    XDo::Keyboard.type("Percentage of smokers in different jobs in Germany".upcase) #type is usually faster than simulate if the text doesn't contain special characters or escape sequences
+    2.times{XDo::Keyboard.return} #Return is the Enter key
+    #Set up the data
+    headings = ["Job", "Percentage"]
+    data = [
+      ["Judge", 28], 
+      ["Architect", 29], 
+      ["Doctor", 30], 
+      ["Nurse", 45], 
+      ["Teacher", 53]
+    ]
+    #Create the table headings
+    str =""
+    headings[0..-2].each{|h| str << h << "{TAB}{TAB}"}
+    str << headings[-1] << "\n"#No tab after the last heading
+    #Type the heading
+    XDo::Keyboard.simulate(str)
+    #Make a line between the heading and the data
+    XDo::Keyboard.type("=" * 30)
+    XDo::Keyboard.return
+    #Write the table data
+    data.each do |job, percentage|
+      #Insert tabs. If a word is longer than 8 (the normal tab size), don't append a second tab. 
+      XDo::Keyboard.simulate("#{job}#{job.length > 8 ? "\t" : "\t\t"}#{percentage}\n") #\t will trigger the Tab key, \n the Return key. 
+    end
+    #Oh yes, and save it of course. XDo::Keyboard tries to 
+    #send every method name as a key combination if the 
+    #method is not defined already. The method name 
+    #will be capitalized and every underscore _ replaced 
+    #by a + (that's internally important to combine keys). 
+    File.delete("#{ENV["HOME"]}/testXDo.txt") if File.file? "#{ENV["HOME"]}/testXDo.txt" #This is the file we'll save to
+    XDo::Keyboard.ctrl_s
+    #Wait for the save window to exist. I can't use wait_for_window here, since 
+    #it's named different in every language. Me as a German user have a title 
+    #of "Speichern unter...", an english OS may show "Save as...". 
+    sleep 1
+    #You really shouldn't try to simulate the ~ sign. xdotool seems to have a bug, so 
+    #~ can't be simulated with one command. My library tries to simulate it with one 
+    #command and it sometimes works, but you mustn't rely on it. Therefore I use 
+    #the HOME environment variable here to get the home directory, rather than ~. 
+    XDo::Keyboard.simulate("#{ENV["HOME"]}/testXDo.txt")
+    sleep 1 #gedit terminates if send [ALT]+[S] immediatly after the path
+    XDo::Keyboard.alt_s
+    #Now, let's duplicate our table. We could send all the stuff again, 
+    #but I want to introduce you in the use of the X clipboard. 
+    #First, we have to mark our text in order to be copied to the clipboard: 
+    xwin.activate #After saving the window isn't active anymore
+    sleep 1 #Wait for the gedit window to be active again
+    XDo::Keyboard.ctrl_a
+    #Then copy it to the clipboard (you see, it's quite useful to know keyboard shortcuts)
+    XDo::Keyboard.ctrl_c
+    #gedit copies, like the most programs, it's data to the CLIPBOARD clipboard. 
+    #There are two other clipboard, PRIMARY and SECONDARY, but we won't 
+    #diskuss them here. If you are sure you've copied data to the clipboard and 
+    ##read_clipboard doesn't find anything, check out #read_primary and #read_secondary. 
+    #Also note, that XDo can only handle plain text data. 
+    cliptext = XDo::Clipboard.read_clipboard
+    #Move to the end of the text
+    XDo::Keyboard.simulate("{DOWN}" * 9)
+    XDo::Keyboard.simulate("{END}")
+    #Since #simulate interprets \t correctly as a tab, we can simply put 
+    #the clipboard's text in that method: 
+    XDo::Keyboard.simulate("\n#{cliptext}") #Begin a new line before inserting the duplicate
+    sleep 1
+    XDo::Keyboard.ctrl_s
+    #Give some time to see the result
+    sleep 5
+    #Than close gedit. There are three methods to close a window, 
+    ##close, #close! and #kill!. #close is like sending an [ALT]+[F4] keypress which may result in 
+    #a dialog box asking you for confirmation. #close! is a bit stronger. First it calls #close and waits 
+    #a few seconds (you can specify how long exactly) then shuts down the window process. What 
+    #leads us to the third method: #kill!. Be sure to call #kill! only on windows you know - 
+    #it kills the process of a window by sending SIGTERM first and then SIGKILL. I've not tried 
+    #what happens if you send this to the desktop window, but if you like to...
+    xwin.close #We use the normal #close here since we saved our data and gedit shouldn't complain. 
+  end
+  
+  def mouse
+    #Assuming that the first entry of your right-click menu is "Create folder", 
+    #you can create new folders on your desktop. 
+    XDo::XWindow.toggle_minimize_all
+    sleep 2
+    
+    #Mouse.click is the method for executing mouse clicks. If you call it 
+    #without any arguments, it will execute a left click on the current cursor position. 
+    XDo::Mouse.click(400, 400, XDo::Mouse::RIGHT)
+    sleep 1 #Give the menu time to appear
+    XDo::Mouse.click
+    sleep 1 #Wait for the folder to be created
+    #Give it a name
+    XDo::Keyboard.simulate("A test folder\n") # Return to confirm
+    sleep 1 #Wait to accept the name
+    #Move the folder icon a bit upwards
+    XDo::Mouse.drag(nil, nil, 400, 200)
+    sleep 2
+    XDo::XWindow.toggle_minimize_all #Restore all windows
+  end
+  
+end
+
+USAGE =<<USAGE
+USAGE: 
+./full_demo.rb [methodname]
+
+Executes the full_demo XDo demo file. You can optionally provide a method 
+name, if you don't, both methods will be run. 
+USAGE
+
+if ARGV.include?("-h") or ARGV.include?("--help")
+  puts USAGE
+end
+
+xxx = XXX.new
+if ARGV.empty?
+  xxx.keyboard
+  sleep 3
+  xxx.mouse
+elsif ARGV[0] == "mouse"
+  xxx.mouse
+elsif ARGV[0] == "keyboard"
+  xxx.keyboard
+else
+  puts USAGE
+end

data/samples/mouse.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+#--
+#This file is part of XDo. Copyright © 2009 Marvin Gülker
+#XDo is published under Ruby's license. See http://www.ruby-lang.org/en/LICENSE.txt. 
+#  Initia in potestate nostra sunt, de eventu fortuna iudicat. 
+#++
+
+=begin
+This is an example on how to use the mouse with XDo::Mouse. 
+=end
+
+#Require the library
+require "xdo/mouse"
+
+#Get current cursor position
+puts "Cursor X pos: #{XDo::Mouse.position[0]}"
+puts "Cursor Y pos: #{XDo::Mouse.position[1]}"
+
+#Move the mouse cursor
+XDo::Mouse.move(10, 10)
+#Click at the current position
+XDo::Mouse.click
+#Do a right-click at (100|100)
+XDo::Mouse.click(100, 100, XDo::Mouse::RIGHT)
+#Scroll down a text page
+XDo::Mouse.wheel(XDo::Mouse::DOWN, 4)

data/test/test_clipboard.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+gem "test-unit", ">= 2.1" #Ensure we use the gem
+require "test/unit"
+require "xdo/clipboard.rb"
+
+class ClipboardTest < Test::Unit::TestCase
+  
+  def test_read
+    #Write something to the clipboard first
+    IO.popen("#{XDo::XSEL} -i", "w"){|io| io.write("Some primary test text")}
+    IO.popen("#{XDo::XSEL} -b -i", "w"){|io| io.write("Some clipboard \ntest text")}
+    IO.popen("#{XDo::XSEL} -s -i", "w"){|io| io.write("Some secondary test text")}
+    
+    clip = XDo::Clipboard.read
+    assert_equal("Some primary test text", XDo::Clipboard.read_primary)
+    assert_equal(XDo::Clipboard.read_primary, clip[:primary])
+    assert_equal("Some clipboard \ntest text", XDo::Clipboard.read_clipboard)
+    assert_equal(XDo::Clipboard.read_clipboard, clip[:clipboard])
+    assert_equal("Some secondary test text", XDo::Clipboard.read_secondary)
+    assert_equal(XDo::Clipboard.read_secondary, clip[:secondary])
+  end
+  
+  def test_write
+    XDo::Clipboard.write_primary "Primary!"
+    XDo::Clipboard.write_clipboard "Clipboard!\nNewline"
+    XDo::Clipboard.write_secondary "Secondary!"
+    
+    assert_equal("Primary!", `#{XDo::XSEL}`)
+    assert_equal("Secondary!", `#{XDo::XSEL} -s`)
+    assert_equal("Clipboard!\nNewline", `#{XDo::XSEL} -b`)
+    
+    XDo::Clipboard.write("XYZ", :primary, :secondary, :clipboard)
+    assert_equal({primary: "XYZ", secondary: "XYZ", clipboard: "XYZ"}, XDo::Clipboard.read)
+  end
+  
+  def test_append
+    ["primary", "secondary", "clipboard"].each{|m| XDo::Clipboard.send(:"write_#{m}", "This is... ")}
+    XDo::Clipboard.append("a Test!", :primary, :secondary, :clipboard)
+    ["primary", "secondary", "clipboard"].each{|m| assert_equal(XDo::Clipboard.send(:"read_#{m}"), "This is... a Test!")}
+  end
+  
+  def test_clear
+    XDo::Clipboard.write("ABC", :primary, :secondary, :clipboard)
+    ["primary", "secondary", "clipboard"].each{|m| XDo::Clipboard.send("clear_#{m}")}
+    ["primary", "secondary", "clipboard"].each{|m| assert_equal("", XDo::Clipboard.send("read_#{m}"))}
+  end
+  
+end

data/test/test_drive.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+gem "test-unit", ">= 2.1" #Ensure we use the gem
+require "test/unit"
+require "xdo/drive.rb"
+
+class DriveTest < Test::Unit::TestCase
+  
+  def test_eject
+    begin
+      XDo::Drive.eject
+      sleep 2
+      begin
+        XDo::Drive.close
+      rescue XDo::XError #A laptop drive will raise an XDo::XError since it has to be closed manually
+        notify "Couldn't close your CD-ROM drive. Are you using a laptop?"
+      end
+      assert(true)
+    rescue
+      assert(false, $!.message)
+    end
+  end
+  
+end

data/test/test_keyboard.rb

@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+gem "test-unit", ">= 2.1" #Ensure we use the gem
+require "test/unit"
+require "tempfile"
+require "xdo/keyboard.rb"
+require "xdo/clipboard.rb"
+require "xdo/xwindow"
+require "xdo/simulatable"
+
+class TestKeyboard < Test::Unit::TestCase
+  
+  #Command to start a simple text editor
+  EDITOR_CMD = "gedit"
+  
+  TESTTEXT = "This is test\ntext."
+  TESTTEXT2 = "XYZ"
+  TESTTEXT_RAW = "ä{TAB}?b"
+  TESTTEXT_SPECIAL = "ab{TAB}c{TAB}{TAB}d"
+  
+  def setup
+    @edit_pid = spawn(EDITOR_CMD)
+    sleep 1
+  end
+  
+  def teardown
+    Process.kill("KILL", @edit_pid)
+  end
+  
+  def test_char
+    Process.kill("KILL", @edit_pid) #Special file need to be opened
+    tempfile = Tempfile.open("XDOTEST")
+    tempfile.write(TESTTEXT)
+    tempfile.flush
+    sleep 1 #Wait for the buffer to be written out
+    @edit_pid = spawn(EDITOR_CMD, tempfile.path) #So it's automatically killed by #teardown
+    sleep 1
+    tempfile.close
+    20.times{XDo::Keyboard.char("Shift+Right")}
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT, XDo::Clipboard.read_clipboard)
+  end
+  
+  def test_simulate
+    XDo::Keyboard.simulate("A{BS}#{TESTTEXT2}")
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT2, XDo::Clipboard.read_clipboard)
+    
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.delete
+    XDo::Keyboard.simulate(TESTTEXT_SPECIAL)
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT_SPECIAL.gsub("{TAB}", "\t"), XDo::Clipboard.read_clipboard)
+    
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.delete
+    XDo::Keyboard.simulate(TESTTEXT_RAW, true)
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT_RAW, XDo::Clipboard.read_clipboard)
+  end
+  
+  def test_type
+    XDo::Keyboard.type(TESTTEXT2)
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT2, XDo::Clipboard.read_clipboard)
+  end
+  
+  def test_window_id
+    XDo::XWindow.unfocus #Ensure that the editor hasn't the input focus anymore
+    sleep 1
+    edit_id = XDo::XWindow.search(EDITOR_CMD).first
+    xwin = XDo::XWindow.new(edit_id)
+    XDo::Keyboard.simulate(TESTTEXT_SPECIAL, false, edit_id)
+    sleep 1
+    xwin.activate
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    assert_equal(TESTTEXT_SPECIAL.gsub("{TAB}", "\t"), XDo::Clipboard.read_clipboard)
+  end
+  
+  def test_include
+    String.class_eval do
+      include XDo::Simulatable
+      
+      def to_xdo
+        to_s
+      end
+    end
+    
+    XDo::Keyboard.ctrl_a
+    XDo::Keyboard.delete
+    "Ein String".simulate
+    XDo::Keyboard.ctrl_a
+    sleep 0.2
+    XDo::Keyboard.ctrl_c
+    sleep 0.2
+    clip = XDo::Clipboard.read_clipboard
+    assert_equal("Ein String", clip)
+  end
+  
+end

data/test/test_mouse.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+gem "test-unit", ">= 2.1" #Ensure we use the gem
+require "test/unit"
+require "xdo/mouse.rb"
+
+class MouseTest < Test::Unit::TestCase
+  
+  def test_position
+    str = `#{XDo::XDOTOOL} getmouselocation`
+    xdpos = []
+    xdpos << str.match(/x:\s?(\d+)/)[1]
+    xdpos << str.match(/y:\s?(\d+)/)[1]
+    xdpos.collect!{|o| o.to_i}
+    assert_equal(xdpos, XDo::Mouse.position)
+  end
+  
+  def test_move
+    XDo::Mouse.move(200, 200)
+    assert_equal([200, 200], XDo::Mouse.position)
+    XDo::Mouse.move(0, 0)
+    assert_equal([0, 0], XDo::Mouse.position)
+    XDo::Mouse.move(0, 200)
+    assert_equal([0, 200], XDo::Mouse.position)
+    XDo::Mouse.move(100, 100)
+    assert_equal([100, 100], XDo::Mouse.position)
+  end
+  
+end

data/test/test_xwindow.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+#Encoding: UTF-8
+gem "test-unit", ">= 2.1" #Ensure we use the gem
+require "test/unit"
+require "xdo/xwindow.rb"
+require "xdo/keyboard"
+
+class WindowTest < Test::Unit::TestCase
+  
+  attr_accessor :xwindow
+  
+  #The command used to create new windows. 
+  #The program MUST NOT start maximized. xdotool has no possibility of 
+  #acting on maximized windows. 
+  NEW_WINDOW_CMD = "gedit"
+  
+  @@xwin = nil
+  
+  def self.startup
+    fork{system(NEW_WINDOW_CMD)}
+    XDo::XWindow.wait_for_window(Regexp.new(Regexp.escape(NEW_WINDOW_CMD)))
+    @@xwin = XDo::XWindow.from_title(Regexp.new(Regexp.escape(NEW_WINDOW_CMD)))
+  end
+  
+  def self.shutdown
+    @@xwin.focus
+    @@xwin.close!
+  end
+  
+  def test_ewmh_active_window
+    begin
+      XDo::XWindow.from_active
+    rescue XDo::XError
+      #Standard not available
+     notify $!.message
+    end
+  end
+  
+  def test_ewmh_wm_desktop
+    begin
+      XDo::XWindow.desktop_num
+    rescue XDo::XError
+      #Standard not available
+      notify $!.message
+    end
+  end
+  
+  def test_ewmh_current_desktop
+    begin
+      XDo::XWindow.desktop
+    rescue XDo::XError
+      #Standard not available
+      notify $!.message
+    end
+  end
+  
+  def test_exists
+    assert_equal(true, XDo::XWindow.exists?(@@xwin.title))
+  end
+  
+  def test_unfocus
+    XDo::XWindow.unfocus
+    assert_raise(XDo::XError){XDo::XWindow.from_active} #Nothing's active anymore    
+  end
+  
+  def test_active
+    @@xwin.activate
+    assert_equal(@@xwin.id, XDo::XWindow.from_active.id)
+  end
+  
+  def test_focused
+    @@xwin.unfocus
+    @@xwin.focus
+    assert_equal(@@xwin.id, XDo::XWindow.from_focused.id)
+  end
+  
+  def test_move
+    @@xwin.move(57, 57)
+    assert_in_delta(50, 60, @@xwin.abs_position[0])
+    assert_in_delta(50, 50, @@xwin.abs_position[1])
+    assert_equal(@@xwin.abs_position, @@xwin.rel_position)
+  end
+  
+  def test_resize
+    @@xwin.resize(500, 500)
+    assert_equal([500, 500], @@xwin.size)
+  end
+
+  def test_map
+    @@xwin.unmap
+    assert_equal(nil, @@xwin.visible?)
+    @@xwin.map
+    assert_block("Window is not visible."){@@xwin.visible?.kind_of?(Integer)}    
+  end
+  
+end
+