rainux-selenium-webdriver 0.0.17

data/common/src/rb/README

@@ -0,0 +1,30 @@
+= selenium-webdriver
+
+This gem provides Ruby bindings for WebDriver and has been tested to work on MRI (1.8.6 through 1.9), JRuby and Rubinius.
+
+= INSTALL
+
+gem install selenium-webdriver
+
+= LINKS
+
+* http://gemcutter.org/gems/selenium-webdriver
+* http://selenium.googlecode.com/svn/trunk/docs/api/rb/index.html
+* http://code.google.com/p/selenium/wiki/RubyBindings
+* http://code.google.com/p/selenium/issues/list
+
+= LICENSE
+
+Copyright 2009 WebDriver committers
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/common/src/rb/lib/selenium-webdriver.rb

@@ -0,0 +1 @@
+require "selenium/webdriver"

data/common/src/rb/lib/selenium/webdriver.rb

@@ -0,0 +1,67 @@
+require "tmpdir"
+require "fileutils"
+
+def have_yajl?
+  require "yajl/json_gem"
+  true
+rescue LoadError
+  false
+end
+
+def have_json?
+  require "json"
+  true
+rescue LoadError
+  false
+end
+
+unless have_yajl? || have_json?
+  raise LoadError, <<-END
+
+       You need to require rubygems or install one of these gems:
+
+           yajl-ruby (best on MRI)
+           json
+           json-jruby (native JRuby)
+           json_pure (any platform)
+
+  END
+end
+
+
+require "selenium/webdriver/core_ext/dir"
+require "selenium/webdriver/error"
+require "selenium/webdriver/platform"
+require "selenium/webdriver/child_process"
+require "selenium/webdriver/target_locator"
+require "selenium/webdriver/navigation"
+require "selenium/webdriver/options"
+require "selenium/webdriver/find"
+require "selenium/webdriver/driver_extensions/takes_screenshot"
+require "selenium/webdriver/keys"
+require "selenium/webdriver/bridge_helper"
+require "selenium/webdriver/driver"
+require "selenium/webdriver/element"
+
+module Selenium
+  module WebDriver
+    Point     = Struct.new(:x, :y)
+    Dimension = Struct.new(:width, :heigth)
+
+    autoload :IE,      'selenium/webdriver/ie'
+    autoload :Remote,  'selenium/webdriver/remote'
+    autoload :Chrome,  'selenium/webdriver/chrome'
+    autoload :Firefox, 'selenium/webdriver/firefox'
+
+    def self.root
+      @root ||= File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "..", ".."))
+    end
+
+    def self.for(*args)
+      WebDriver::Driver.for(*args)
+    end
+
+  end # WebDriver
+end # Selenium
+
+Thread.abort_on_exception = true

data/common/src/rb/lib/selenium/webdriver/bridge_helper.rb

@@ -0,0 +1,91 @@
+module Selenium
+  module WebDriver
+
+    #
+    # Shared across bridges
+    #
+
+    module BridgeHelper
+
+      def wrap_script_argument(arg)
+        case arg
+        when Integer, Float
+          { :type => "NUMBER", :value => arg }
+        when TrueClass, FalseClass, NilClass
+          { :type => "BOOLEAN", :value => !!arg }
+        when Element
+          { :type => "ELEMENT", :value => arg.ref }
+        when String
+          { :type => "STRING", :value => arg.to_s }
+        when Array # Enumerable?
+          arg.map { |e| wrap_script_argument(e) }
+        else
+          raise TypeError, "Parameter is not of recognized type: #{arg.inspect}:#{arg.class}"
+        end
+      end
+
+      def unwrap_script_argument(arg)
+        if arg.kind_of?(Array)
+          arg.map { |e| unwrap_script_argument(e) }
+        else
+          case arg["type"]
+          when "NULL"
+            nil
+          when "ELEMENT"
+            Element.new self, element_id_from(arg["value"])
+          when "POINT"
+            Point.new arg['x'], arg['y']
+          when "DIMENSION"
+            Dimension.new arg['width'], arg['height']
+          when "COOKIE"
+            {:name => arg['name'], :value => arg['value']}
+          else
+            arg["value"]
+          end
+        end
+      end
+
+      def element_id_from(id)
+        str = id.kind_of?(Array) ? id.first : id
+        after = str.split("/").last
+
+        after
+      end
+
+      def parse_cookie_string(str)
+        result = {
+          'name'    => '',
+          'value'   => '',
+          'domain'  => '',
+          'path'    => '',
+          'expires' => '',
+          'secure'  => false
+        }
+
+        str.split(";").each do |attribute|
+          if attribute.include? "="
+            key, value = attribute.strip.split("=", 2)
+            if result['name'].empty?
+              result['name']  = key
+              result['value'] = value
+            elsif key == 'domain' && value.strip =~ /^\.(.+)/
+              result['domain'] = $1
+            elsif key && value
+              result[key] = value
+            end
+          elsif attribute == "secure"
+            result['secure'] = true
+          end
+
+          unless [nil, "", "0"].include?(result['expires'])
+            # firefox stores expiry as number of seconds
+            result['expires'] = Time.at(result['expires'].to_i)
+          end
+        end
+
+        result
+      end
+
+    end # BridgeHelper
+  end # WebDriver
+end # Selenium

data/common/src/rb/lib/selenium/webdriver/child_process.rb

@@ -0,0 +1,180 @@
+module Selenium
+  module WebDriver
+
+    #
+    # Cross platform child process launcher
+    #
+
+    class ChildProcess
+      attr_reader :pid
+
+      def initialize(*args)
+        @args = args
+
+        if Platform.jruby?
+          extend JRubyProcess
+        elsif Platform.ironruby?
+          extend IronRubyProcess
+        elsif Platform.os == :windows
+          extend WindowsProcess
+        end
+      end
+
+      def ugly_death?
+        code = exit_value()
+        # if exit_val is nil, the process is still alive
+        code && code != 0
+      end
+
+      def exit_value
+        pid, status = Process.waitpid2(@pid, Process::WNOHANG)
+        status.exitstatus if pid
+      end
+
+      def start
+        @pid = fork do
+          unless $DEBUG
+            [STDOUT, STDERR].each { |io| io.reopen("/dev/null") }
+          end
+
+          exec(*@args)
+        end
+
+        self
+      end
+
+      def wait
+        assert_started
+        Process.waitpid2 @pid
+      rescue Errno::ECHILD
+        nil
+      end
+
+      def kill
+        assert_started
+        Process.kill('TERM', @pid)
+      end
+
+      def kill!
+        assert_started
+        Process.kill('KILL', @pid)
+      end
+
+      def assert_started
+        raise Error::WebDriverError, "process not started" unless @pid
+      end
+
+      module WindowsProcess
+        def start
+          require "win32/process" # adds a dependency on windows - perhaps we could just use FFI instead?
+          @pid = Process.create(
+            :app_name        => @args.join(" "),
+            :inherit         => false # don't inherit open file handles
+          ).process_id
+
+          self
+        end
+
+        def kill
+          kill!
+        end
+      end
+
+      module JRubyProcess
+        def start
+          pb = java.lang.ProcessBuilder.new(@args)
+
+          env = pb.environment
+          ENV.each { |k,v| env.put(k, v) }
+
+          @process = pb.start
+
+          # Firefox 3.6 on Snow Leopard has a lot output on stderr, which makes
+          # the launch act funny if we don't do something to the streams
+
+          @process.getErrorStream.close
+          @process.getInputStream.close
+
+          # Closing the streams solves that problem, but on other platforms we might
+          # need to actually read them.
+
+          # Thread.new do
+          #   input, error = 0, 0
+          #   loop do
+          #     error = @process.getErrorStream.read if error != -1
+          #     input = @process.getInputStream.read if input != -1
+          #     break if error == -1 && input == -1
+          #   end
+          # end
+
+          self
+        end
+
+        def kill
+          assert_started
+          @process.destroy
+        end
+        alias_method :kill!, :kill
+
+        def wait
+          assert_started
+          @process.waitFor
+          [nil, @process.exitValue] # no robust way to get pid here
+        end
+
+        def exit_value
+          assert_started
+          @process.exitValue
+        rescue java.lang.IllegalThreadStateException
+          nil
+        end
+
+        def assert_started
+          raise Error::WebDriverError, "process not started" unless @process
+        end
+      end
+
+      module IronRubyProcess
+        def start
+          args = @args.dup
+
+          @process                           = System::Diagnostics::Process.new
+          @process.StartInfo.UseShellExecute = true
+          @process.StartInfo.FileName        = args.shift
+          @process.StartInfo.Arguments       = args.join ' '
+          @process.start
+
+          self
+        end
+
+        def kill
+          assert_started
+          @process.Kill
+        end
+
+        def wait
+          assert_started
+          @process.WaitForExit
+          [pid, exit_value]
+        end
+
+        def pid
+          assert_started
+          @process.Id
+        end
+
+        def exit_value
+          assert_started
+          return unless @process.HasExited
+
+          @process.ExitCode
+        end
+
+        def assert_started
+          raise Error::WebDriverError, "process not started" unless @process
+        end
+      end
+
+    end # ChildProcess
+  end # WebDriver
+end # Selenium

data/common/src/rb/lib/selenium/webdriver/core_ext/dir.rb

@@ -0,0 +1,41 @@
+class Dir
+  def self.mktmpdir(prefix_suffix=nil, tmpdir=nil)
+    case prefix_suffix
+    when nil
+      prefix = "d"
+      suffix = ""
+    when String
+      prefix = prefix_suffix
+      suffix = ""
+    when Array
+      prefix = prefix_suffix[0]
+      suffix = prefix_suffix[1]
+    else
+      raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+    end
+    tmpdir ||= Dir.tmpdir
+    t = Time.now.strftime("%Y%m%d")
+    n = nil
+    begin
+      path = "#{tmpdir}/#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+      path << "-#{n}" if n
+      path << suffix
+      Dir.mkdir(path, 0700)
+    rescue Errno::EEXIST
+      n ||= 0
+      n += 1
+      retry
+    end
+
+    if block_given?
+      begin
+        yield path
+      ensure
+        FileUtils.remove_entry_secure path
+      end
+    else
+      path
+    end
+  end unless respond_to? :mktmpdir # > 1.8.7
+end
+

data/common/src/rb/lib/selenium/webdriver/driver.rb

@@ -0,0 +1,252 @@
+module Selenium
+  module WebDriver
+
+    #
+    # The main class through which you control the browser.
+    #
+    # @see Find
+    # @see Navigation
+    # @see TargetLocator
+    # @see Options
+    #
+
+    class Driver
+      include Find
+
+      attr_reader :bridge
+
+      class << self
+
+        #
+        # Create a new Driver instance with the correct bridge for the given browser
+        #
+        # @param browser [Symbol]
+        #   the driver type to use
+        # @param *rest
+        #   arguments passed to the Bridge.new
+        #
+        # @return [Driver]
+        #
+
+        def for(browser, *args)
+          bridge = case browser
+                   when :ie, :internet_explorer
+                     WebDriver::IE::Bridge.new(*args)
+                   when :remote
+                     WebDriver::Remote::Bridge.new(*args)
+                   when :chrome
+                     WebDriver::Chrome::Bridge.new(*args)
+                   when :firefox, :ff
+                     WebDriver::Firefox::Bridge.new(*args)
+                   else
+                     raise ArgumentError, "unknown driver: #{browser.inspect}"
+                   end
+
+           driver = new(bridge)
+
+           unless bridge.driver_extensions.empty?
+             driver.extend(*bridge.driver_extensions)
+           end
+
+           driver
+        end
+      end
+
+      #
+      # A new Driver instance
+      #
+      # @api private
+      #
+
+      def initialize(bridge)
+        @bridge = bridge
+      end
+
+      def inspect
+        '#<%s:0x%x browser=%s>' % [self.class, hash*2, bridge.browser.inspect]
+      end
+
+      #
+      # @return [Navigation]
+      # @see Navigation
+      #
+
+      def navigate
+        @navigate ||= WebDriver::Navigation.new(self)
+      end
+
+      #
+      # @return [TargetLocator]
+      # @see TargetLocator
+      #
+
+      def switch_to
+        @switch_to ||= WebDriver::TargetLocator.new(self)
+      end
+
+      #
+      # @return [Options]
+      # @see Options
+      #
+
+      def manage
+        @manage ||= WebDriver::Options.new(self)
+      end
+
+      #
+      # Opens the specified URL in the browser.
+      #
+
+      def get(url)
+        navigate.to(url)
+      end
+
+      #
+      # Get the URL of the current page
+      #
+      # @return [String]
+      #
+
+      def current_url
+        bridge.getCurrentUrl
+      end
+
+      #
+      # Get the title of the current page
+      #
+      # @return [String]
+      #
+
+      def title
+        bridge.getTitle
+      end
+
+      #
+      # Get the source of the current page
+      #
+      # @return [String]
+      #
+
+      def page_source
+        bridge.getPageSource
+      end
+
+      #
+      # Get the visibility of the browser. Not applicable for all browsers.
+      #
+      # @return [Boolean]
+      #
+
+      def visible?
+        bridge.getBrowserVisible
+      end
+
+      #
+      # Set the visibility of the browser. Not applicable for all browsers.
+      #
+      # @param [Boolean]
+      #
+
+      def visible=(bool)
+        bridge.setBrowserVisible bool
+      end
+
+      #
+      # Quit the browser
+      #
+
+      def quit
+        bridge.quit
+      end
+
+      #
+      # Close the current window, or the browser if no windows are left.
+      #
+
+      def close
+        bridge.close
+      end
+
+      #
+      # Get the window handles of open browser windows.
+      #
+      # @return [Array]
+      # @see TargetLocator#window
+      #
+
+      def window_handles
+        bridge.getWindowHandles
+      end
+
+      #
+      # Get the current window handle
+      #
+      # @return [String]
+      #
+
+      def window_handle
+        bridge.getCurrentWindowHandle
+      end
+
+      #
+      # Execute the given JavaScript
+      #
+      # @param [String] script
+      #   JavaScript source to execute
+      # @param [WebDriver::Element,Integer, Float, Boolean, NilClass, String, Array] *args
+      #   Arguments will be available in the given script as the 'arguments' array.
+      #
+      # @return [WebDriver::Element,Integer,Float,Boolean,NilClass,String,Array]
+      #   The value returned from the script.
+      #
+
+      def execute_script(script, *args)
+        bridge.executeScript(script, *args)
+      end
+
+      #-------------------------------- sugar  --------------------------------
+
+      #
+      #   driver.first(:id, 'foo')
+      #
+
+      alias_method :first, :find_element
+
+      #
+      #   driver.all(:class, 'bar') #=> [#<WebDriver::Element:0x1011c3b88, ...]
+      #
+
+      alias_method :all, :find_elements
+
+      #
+      #   driver.script('function() { ... };')
+      #
+
+      alias_method :script, :execute_script
+
+      # Get the first element matching the given id.
+      #
+      # @param [String] id
+      # @return [WebDriver::Element]
+      #
+      #   driver['someElementId'] #=> #<WebDriver::Element:0x1011c3b88>
+      #
+
+      def [](id)
+        find_element :id, id
+      end
+
+
+      #
+      # for Find
+      #
+      # @api private
+      #
+
+      def ref
+        nil
+      end
+
+    end # Driver
+  end # WebDriver
+end # Selenium