bbc-selenium-webdriver 1.17.0

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

@@ -0,0 +1,166 @@
+require 'rbconfig'
+require 'socket'
+
+module Selenium
+  module WebDriver
+
+    # @api private
+    module Platform
+
+      module_function
+
+      def home
+        # jruby has an issue with ENV['HOME'] on Windows
+        @home ||= jruby? ? ENV_JAVA['user.home'] : ENV['HOME']
+      end
+
+      def engine
+        @engine ||= (
+          if defined? RUBY_ENGINE
+            RUBY_ENGINE.to_sym
+          else
+            :ruby
+          end
+        )
+      end
+
+      def os
+        @os ||= (
+          host_os = RbConfig::CONFIG['host_os']
+          case host_os
+          when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+            :windows
+          when /darwin|mac os/
+            :macosx
+          when /linux/
+            :linux
+          when /solaris|bsd/
+            :unix
+          else
+            raise Error::WebDriverError, "unknown os: #{host_os.inspect}"
+          end
+        )
+      end
+
+      def bitsize
+        @bitsize ||= (
+          if defined?(FFI::Platform::ADDRESS_SIZE)
+            FFI::Platform::ADDRESS_SIZE
+          elsif defined?(FFI)
+            FFI.type_size(:pointer) == 4 ? 32 : 64
+          elsif jruby?
+            Integer(ENV_JAVA['sun.arch.data.model'])
+          else
+            1.size == 4 ? 32 : 64
+          end
+        )
+      end
+
+      def jruby?
+        engine == :jruby
+      end
+
+      def ironruby?
+        engine == :ironruby
+      end
+
+      def ruby187?
+        !!(RUBY_VERSION =~ /^1\.8\.7/)
+      end
+
+      def ruby19?
+        !!(RUBY_VERSION =~ /^1\.9/)
+      end
+
+      def windows?
+        os == :windows
+      end
+
+      def mac?
+        os == :macosx
+      end
+
+      def linux?
+        os == :linux
+      end
+
+      def cygwin?
+        !!(RUBY_PLATFORM =~ /cygwin/)
+      end
+
+      def wrap_in_quotes_if_necessary(str)
+        windows? && !cygwin? ? %{"#{str}"} : str
+      end
+
+      def cygwin_path(path, opts = {})
+        flags = []
+        opts.each { |k,v| flags << "--#{k}" if v }
+
+        `cygpath #{flags.join ' '} "#{path}"`.strip
+      end
+
+      def make_writable(file)
+        File.chmod 0766, file
+      end
+
+      def assert_file(path)
+        unless File.file? path
+          raise Error::WebDriverError, "not a file: #{path.inspect}"
+        end
+      end
+
+      def assert_executable(path)
+        assert_file(path)
+
+        unless File.executable? path
+          raise Error::WebDriverError, "not executable: #{path.inspect}"
+        end
+      end
+
+      def exit_hook(&blk)
+        pid = Process.pid
+
+        at_exit do
+          yield if Process.pid == pid
+        end
+      end
+
+      def find_binary(*binary_names)
+        paths = ENV['PATH'].split(File::PATH_SEPARATOR)
+        binary_names.map! { |n| "#{n}.exe" } if windows?
+
+        binary_names.each do |binary_name|
+          paths.each do |path|
+            exe = File.join(path, binary_name)
+            return exe if File.executable?(exe)
+          end
+        end
+
+        nil
+      end
+
+      def localhost
+        info = Socket.getaddrinfo "localhost", 80, Socket::AF_INET, Socket::SOCK_STREAM
+
+        if info.empty?
+          raise Error::WebDriverError, "unable to translate 'localhost' for TCP + IPv4"
+        end
+
+        info[0][3]
+      end
+
+    end # Platform
+  end # WebDriver
+end # Selenium
+
+if __FILE__ == $0
+  p :engine    => Selenium::WebDriver::Platform.engine,
+    :os        => Selenium::WebDriver::Platform.os,
+    :ruby187?  => Selenium::WebDriver::Platform.ruby187?,
+    :ruby19?   => Selenium::WebDriver::Platform.ruby19?,
+    :jruby?    => Selenium::WebDriver::Platform.jruby?,
+    :windows?  => Selenium::WebDriver::Platform.windows?,
+    :home      => Selenium::WebDriver::Platform.home,
+    :bitsize   => Selenium::WebDriver::Platform.bitsize,
+    :localhost => Selenium::WebDriver::Platform.localhost
+end

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

@@ -0,0 +1,25 @@
+module Selenium
+  module WebDriver
+    class PortProber
+      def self.above(port)
+        port += 1 until free? port
+        port
+      end
+      
+      def self.random
+        server = TCPServer.new(Platform.localhost, 0)
+        port   = server.addr[1]
+        server.close
+        
+        port
+      end
+      
+      def self.free?(port)
+        TCPServer.new(Platform.localhost, port).close
+        true
+      rescue SocketError, Errno::EADDRINUSE
+        false
+      end
+    end # PortProber
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,67 @@
+module Selenium
+  module WebDriver
+
+    #
+    # @api private
+    #
+    # Common methods for Chrome::Profile and Firefox::Profile
+    # Includers must implement #layout_on_disk
+    #
+
+    module ProfileHelper
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def as_json(opts = nil)
+        {'zip' => Zipper.zip(layout_on_disk)}
+      end
+
+      def to_json(*args)
+        MultiJson.encode as_json
+      end
+
+      private
+
+      def create_tmp_copy(directory)
+        tmp_directory = Dir.mktmpdir("webdriver-rb-profilecopy")
+
+        # TODO: must be a better way..
+        FileUtils.rm_rf tmp_directory
+        FileUtils.mkdir_p File.dirname(tmp_directory), :mode => 0700
+        FileUtils.cp_r directory, tmp_directory
+
+        tmp_directory
+      end
+
+      def verify_model(model)
+        return unless model
+
+        raise Errno::ENOENT, model unless File.exist?(model)
+        raise Errno::ENOTDIR, model unless File.directory?(model)
+
+        model
+      end
+
+      module ClassMethods
+        def from_json(json)
+          data = MultiJson.decode(json).fetch('zip')
+
+          # can't use Tempfile here since it doesn't support File::BINARY mode on 1.8
+          # can't use Dir.mktmpdir(&blk) because of http://jira.codehaus.org/browse/JRUBY-4082
+          tmp_dir = Dir.mktmpdir
+          begin
+            zip_path = File.join(tmp_dir, "webdriver-profile-duplicate-#{json.hash}.zip")
+            File.open(zip_path, "wb") { |zip_file| zip_file << Base64.decode64(data) }
+
+            new Zipper.unzip(zip_path)
+          ensure
+            FileUtils.rm_rf tmp_dir
+          end
+        end
+      end # ClassMethods
+
+    end # ProfileHelper
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,120 @@
+module Selenium
+  module WebDriver
+    class Proxy
+      TYPES = {
+        :direct      => "DIRECT",     # Direct connection, no proxy (default on Windows).
+        :manual      => "MANUAL",     # Manual proxy settings (e.g., for httpProxy).
+        :pac         => "PAC",        # Proxy autoconfiguration from URL.
+        :auto_detect => "AUTODETECT", # Proxy autodetection (presumably with WPAD).
+        :system      => "SYSTEM"      # Use system settings (default on Linux).
+      }
+
+      attr_reader :type,
+                  :ftp,
+                  :http,
+                  :no_proxy,
+                  :pac,
+                  :ssl,
+                  :auto_detect
+
+      def initialize(opts = {})
+        opts = opts.dup
+
+        self.type        = opts.delete(:type) if opts.has_key? :type
+        self.ftp         = opts.delete(:ftp) if opts.has_key? :ftp
+        self.http        = opts.delete(:http) if opts.has_key? :http
+        self.no_proxy    = opts.delete(:no_proxy) if opts.has_key? :no_proxy
+        self.ssl         = opts.delete(:ssl) if opts.has_key? :ssl
+        self.pac         = opts.delete(:pac) if opts.has_key? :pac
+        self.auto_detect = opts.delete(:auto_detect) if opts.has_key? :auto_detect
+
+        unless opts.empty?
+          raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
+        end
+      end
+
+      def ==(other)
+        other.kind_of?(self.class) && as_json == other.as_json
+      end
+      alias_method :eql?, :==
+
+      def ftp=(value)
+        self.type = :manual
+        @ftp = value
+      end
+
+      def http=(value)
+        self.type = :manual
+        @http = value
+      end
+
+      def no_proxy=(value)
+        self.type = :manual
+        @no_proxy = value
+      end
+
+      def ssl=(value)
+        self.type = :manual
+        @ssl = value
+      end
+
+      def pac=(url)
+        self.type = :pac
+        @pac = url
+      end
+
+      def auto_detect=(bool)
+        self.type = :auto_detect
+        @auto_detect = bool
+      end
+
+      def type=(type)
+        unless TYPES.has_key? type
+          raise ArgumentError, "invalid proxy type: #{type.inspect}, expected one of #{TYPES.keys.inspect}"
+        end
+
+        if defined?(@type) && type != @type
+          raise ArgumentError, "incompatible proxy type #{type.inspect} (already set to #{@type.inspect})"
+        end
+
+        @type = type
+      end
+
+      def as_json(opts = nil)
+        json_result = {
+          "proxyType" => TYPES[type]
+        }
+
+        json_result["ftpProxy"]           = ftp if ftp
+        json_result["httpProxy"]          = http if http
+        json_result["noProxy"]            = no_proxy if no_proxy
+        json_result["proxyAutoconfigUrl"] = pac if pac
+        json_result["sslProxy"]           = ssl if ssl
+        json_result["autodetect"]         = auto_detect if auto_detect
+
+        json_result if json_result.length > 1
+      end
+
+      def to_json(*args)
+        MultiJson.encode as_json
+      end
+
+      class << self
+        def json_create(data)
+          proxy = new
+
+          proxy.type        = data['proxyType'].downcase.to_sym if data.has_key? 'proxyType'
+          proxy.ftp         = data['ftpProxy'] if data.has_key? 'ftpProxy'
+          proxy.http        = data['httpProxy'] if data.has_key? 'httpProxy'
+          proxy.no_proxy    = data['noProxy'] if data.has_key? 'noProxy'
+          proxy.pac         = data['proxyAutoconfigUrl'] if data.has_key? 'proxyAutoconfigUrl'
+          proxy.ssl         = data['sslProxy'] if data.has_key? 'sslProxy'
+          proxy.auto_detect = data['autodetect'] if data.has_key? 'autodetect'
+
+          proxy
+        end
+      end # class << self
+
+    end # Proxy
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,92 @@
+module Selenium
+  module WebDriver
+    module SearchContext
+
+      # @api private
+      FINDERS = {
+        :class             => 'class name',
+        :class_name        => 'class name',
+        :css               => 'css selector',
+        :id                => 'id',
+        :link              => 'link text',
+        :link_text         => 'link text',
+        :name              => 'name',
+        :partial_link_text => 'partial link text',
+        :tag_name          => 'tag name',
+        :xpath             => 'xpath',
+      }
+
+      #
+      # Find the first element matching the given arguments.
+      #
+      # When using Element#find_element with :xpath, be aware that webdriver
+      # follows standard conventions: a search prefixed with "//" will search
+      # the entire document, not just the children of this current node. Use
+      # ".//" to limit your search to the children of the receiving Element.
+      #
+      # @param [:class, :class_name, :css, :id, :link_text, :link, :partial_link_text, :name, :tag_name, :xpath] how
+      # @param [String] what
+      # @return [Element]
+      #
+      # @raise [Error::NoSuchElementError] if the element doesn't exist
+      #
+      #
+
+      def find_element(*args)
+        how, what = extract_args(args)
+
+        unless by = FINDERS[how.to_sym]
+          raise ArgumentError, "cannot find element by #{how.inspect}"
+        end
+
+        bridge.find_element_by by, what.to_s, ref
+      end
+
+      #
+      # Find all elements matching the given arguments
+      #
+      # @see SearchContext#find_element
+      #
+      # @param [:class, :class_name, :css, :id, :link_text, :link, :partial_link_text, :name, :tag_name, :xpath] how
+      # @param [String] what
+      # @return [Array<Element>]
+      #
+
+      def find_elements(*args)
+        how, what = extract_args(args)
+
+        unless by = FINDERS[how.to_sym]
+          raise ArgumentError, "cannot find elements by #{how.inspect}"
+        end
+
+        bridge.find_elements_by by, what.to_s, ref
+      end
+
+      private
+
+      def extract_args(args)
+        case args.size
+        when 2
+          args
+        when 1
+          arg = args.first
+
+          unless arg.respond_to?(:shift)
+            raise ArgumentError, "expected #{arg.inspect}:#{arg.class} to respond to #shift"
+          end
+
+          # this will be a single-entry hash, so use #shift over #first or #[]
+          arr = arg.dup.shift
+          unless arr.size == 2
+            raise ArgumentError, "expected #{arr.inspect} to have 2 elements"
+          end
+
+          arr
+        else
+          raise ArgumentError, "wrong number of arguments (#{args.size} for 2)"
+        end
+      end
+
+    end # SearchContext
+  end # WebDriver
+end # Selenium