watir 1.4.1 → 7.3.0

data/lib/watir/window.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module Watir
+  class Window
+    include Waitable
+    include Exception
+
+    attr_reader :browser
+
+    def initialize(browser, selector = {})
+      @browser = browser
+      @driver = browser.driver
+      @selector = selector
+
+      if selector.empty?
+        @handle = current_window
+      elsif selector.key? :handle
+        @handle = selector.delete :handle
+      else
+        types = %i[title url element]
+        return if selector.keys.all? { |k| types.include? k }
+
+        raise ArgumentError, "invalid window selector: #{selector_string}"
+      end
+    end
+
+    def inspect
+      format('#<%<class>s:0x%<hash>x located=%<handle>s>',
+             class: self.class, hash: hash * 2, handle: !!@handle)
+    end
+
+    #
+    # Returns window size.
+    #
+    # @example
+    #   size = browser.window.size
+    #   [size.width, size.height] #=> [1600, 1200]
+    #
+
+    def size
+      use { return @driver.manage.window.size }
+    end
+
+    #
+    # Returns window position.
+    #
+    # @example
+    #   position = browser.window.position
+    #   [position.x, position.y] #=> [92, 76]
+    #
+
+    def position
+      use { return @driver.manage.window.position }
+    end
+
+    #
+    # Resizes window to given width and height.
+    #
+    # @example
+    #   browser.window.resize_to 1600, 1200
+    #
+    # @param [Integer] width
+    # @param [Integer] height
+    #
+
+    def resize_to(width, height)
+      Selenium::WebDriver::Dimension.new(Integer(width), Integer(height)).tap do |dimension|
+        use { @driver.manage.window.size = dimension }
+      end
+    end
+
+    #
+    # Moves window to given x and y coordinates.
+    #
+    # @example
+    #   browser.window.move_to 300, 200
+    #
+    # @param [Integer] x_coord
+    # @param [Integer] y_coord
+    #
+
+    def move_to(x_coord, y_coord)
+      Selenium::WebDriver::Point.new(Integer(x_coord), Integer(y_coord)).tap do |point|
+        use { @driver.manage.window.position = point }
+      end
+    end
+
+    #
+    # Maximizes window.
+    #
+    # @example
+    #   browser.window.maximize
+    #
+
+    def maximize
+      use { @driver.manage.window.maximize }
+    end
+
+    #
+    # Minimize window.
+    #
+    # @example
+    #   browser.window.minimize
+    #
+
+    def minimize
+      use { @driver.manage.window.minimize }
+    end
+
+    #
+    # Make window full screen.
+    #
+    # @example
+    #   browser.window.full_screen
+    #
+
+    def full_screen
+      use { @driver.manage.window.full_screen }
+    end
+
+    #
+    # Returns true if window exists.
+    #
+    # @return [Boolean]
+    #
+
+    def exists?
+      assert_exists
+      true
+    rescue NoMatchingWindowFoundException
+      false
+    end
+
+    alias present? exists?
+    alias exist? exists?
+
+    #
+    # Returns true if two windows are equal.
+    #
+    # @example
+    #   browser.window(title: /window_switching/) == browser.window(/closeable/)
+    #   #=> false
+    #
+    # @param [Window] other
+    #
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      handle == other.handle
+    end
+    alias eql? ==
+
+    def hash
+      [handle, self.class].hash
+    end
+
+    #
+    # Returns true if window is current.
+    #
+    # @example
+    #   browser.window.current?
+    #   #=> true
+    #
+
+    def current?
+      current_window == handle
+    end
+
+    #
+    # Closes window.
+    #
+
+    def close
+      @browser.original_window = nil if self == @browser.original_window
+      use { @driver.close }
+    end
+
+    #
+    # Returns window title.
+    #
+    # @return [String]
+    #
+
+    def title
+      use { return @driver.title }
+    end
+
+    #
+    # Returns window URL.
+    #
+    # @return [String]
+    #
+
+    def url
+      use { return @driver.current_url }
+    end
+
+    #
+    # Switches to given window and executes block, then switches back.
+    #
+    # @example
+    #   browser.window(title: "closeable window").use do
+    #     browser.a(id: "close").click
+    #   end
+    #
+
+    def use
+      wait_for_exists
+      cache_current = current_window
+      @browser.original_window ||= cache_current
+      restore_to = unless cache_current == handle
+                     @driver.switch_to.window(handle)
+                     cache_current
+                   end
+      if block_given?
+        begin
+          yield
+        ensure
+          @driver.switch_to.window(restore_to) if restore_to
+        end
+      end
+      self
+    end
+
+    #
+    # @api private
+    #
+
+    def selector_string
+      @selector.inspect
+    end
+
+    def handle
+      @handle ||= locate
+    end
+
+    private
+
+    def locate
+      @selector.empty? ? nil : @driver.window_handles.find { |wh| matches?(wh) }
+    end
+
+    def assert_exists
+      return if !handle.nil? && @driver.window_handles.include?(handle)
+
+      raise(NoMatchingWindowFoundException, selector_string)
+    end
+
+    # return a handle to the currently active window if it is still open; otherwise nil
+    def current_window
+      @driver.window_handle
+    rescue Selenium::WebDriver::Error::NoSuchWindowError
+      nil
+    end
+
+    def matches?(handle)
+      @driver.switch_to.window(handle) do
+        matches_title = @selector[:title].nil? || @browser.title =~ /#{@selector[:title]}/
+        matches_url = @selector[:url].nil? || @browser.url =~ /#{@selector[:url]}/
+        matches_element = @selector[:element].nil? || @selector[:element].exists?
+
+        matches_title && matches_url && matches_element
+      end
+    rescue Selenium::WebDriver::Error::NoSuchWindowError
+      # the window may disappear while we're iterating.
+      false
+    end
+
+    def wait_for_exists
+      wait_until(&:exists?)
+    rescue Wait::TimeoutError
+      raise NoMatchingWindowFoundException, selector_string
+    end
+  end # Window
+end # Watir

data/lib/watir/window_collection.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Watir
+  class WindowCollection
+    include Enumerable
+    include Waitable
+
+    def initialize(browser, selector = {})
+      types = %i[title url element]
+      unless selector.keys.all? { |k| types.include? k }
+        raise ArgumentError, "invalid window selector: #{selector.inspect}"
+      end
+
+      @browser = browser
+      @selector = selector
+    end
+
+    #
+    # Yields each window in collection.
+    #
+    # @yieldparam [Watir::Window]
+    #
+
+    def each(&blk)
+      reset!
+      window_list.each(&blk)
+    end
+
+    alias length count
+    alias size count
+    alias empty? none?
+
+    def [](*)
+      raise NoMethodError, 'indexing not reliable on WindowCollection'
+    end
+    alias first []
+    alias last []
+    alias to_a []
+
+    def ==(other)
+      window_list == other.send(:window_list)
+    end
+    alias eql? ==
+
+    def restore!
+      return if @browser.closed?
+
+      window_list.reject { |win| win.handle == @browser.original_window.handle }.each(&:close)
+      @browser.original_window.use
+    rescue StandardError
+      @browser.close
+    end
+
+    def reset!
+      @window_list = nil
+    end
+
+    private
+
+    def window_list
+      @window_list ||= begin
+        handles = @browser.driver.window_handles.select { |wh| matches?(wh) }
+        handles.map { |wh| Window.new(@browser, handle: wh) }
+      end
+    end
+
+    # NOTE: This is the exact same code from `Window#matches?`
+    # TODO: Move this code into a separate WindowLocator class
+    def matches?(handle)
+      @selector.empty? || @browser.driver.switch_to.window(handle) do
+        matches_title = @selector[:title].nil? || @browser.title =~ /#{@selector[:title]}/
+        matches_url = @selector[:url].nil? || @browser.url =~ /#{@selector[:url]}/
+        matches_element = @selector[:element].nil? || @selector[:element].exists?
+
+        matches_title && matches_url && matches_element
+      end
+    rescue Selenium::WebDriver::Error::NoSuchWindowError
+      # the window may disappear while we're iterating.
+      false
+    end
+  end # Window
+end # Watir

data/lib/watir.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'selenium-webdriver'
+require 'time'
+
+require 'watir/search_context'
+require 'watir/scroll'
+require 'watir/wait'
+require 'watir/exception'
+require 'watir/window'
+require 'watir/window_collection'
+require 'watir/has_window'
+require 'watir/adjacent'
+require 'watir/js_execution'
+require 'watir/alert'
+require 'watir/js_snippets'
+require 'watir/container'
+require 'watir/cookies'
+require 'watir/http_client'
+require 'watir/capabilities'
+require 'watir/navigation'
+require 'watir/browser'
+require 'watir/screenshot'
+require 'watir/after_hooks'
+require 'watir/logger'
+require 'watir/version'
+
+module Watir
+  class << self
+    attr_writer :default_timeout
+
+    #
+    # Default wait time for wait methods.
+    #
+
+    def default_timeout
+      @default_timeout ||= 30
+    end
+
+    #
+    # @api private
+    #
+
+    def tag_to_class
+      @tag_to_class ||= {}
+    end
+
+    #
+    # @api private
+    #
+
+    def element_class_for(tag_name)
+      tag_to_class[tag_name.to_sym] || HTMLElement
+    end
+  end
+
+  #
+  # Returns logger instance that can be used across the whole Selenium.
+  #
+  # @return [Logger]
+  #
+
+  def self.logger
+    @logger ||= Logger.new
+  end
+end
+require 'watir/locators'
+
+require 'watir/attribute_helper'
+require 'watir/row_container'
+require 'watir/cell_container'
+require 'watir/user_editable'
+require 'watir/element_collection'
+require 'watir/elements/element'
+
+require 'watir/elements/html_elements'
+require 'watir/elements/svg_elements'
+
+require 'watir/elements/button'
+require 'watir/elements/cell'
+require 'watir/elements/checkbox'
+require 'watir/elements/date_field'
+require 'watir/elements/date_time_field'
+require 'watir/elements/dlist'
+require 'watir/elements/file_field'
+require 'watir/elements/font'
+require 'watir/elements/form'
+require 'watir/elements/iframe'
+require 'watir/elements/hidden'
+require 'watir/elements/image'
+require 'watir/elements/link'
+require 'watir/elements/list'
+require 'watir/elements/option'
+require 'watir/elements/radio'
+require 'watir/elements/row'
+require 'watir/elements/select'
+require 'watir/elements/table'
+require 'watir/elements/table_cell'
+require 'watir/elements/table_row'
+require 'watir/elements/table_section'
+require 'watir/elements/text_area'
+require 'watir/elements/text_field'
+require 'watir/elements/input'
+require 'watir/radio_set'
+require 'watir/shadow_root'
+
+require 'watir/aliases'

data/lib/watirspec/guards.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module WatirSpec
+  module Guards
+    class << self
+      def guards
+        @guards ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def record(guard_name, impls, data)
+        guards[impls] << {name: guard_name, data: data}
+      end
+
+      def report
+        gs = WatirSpec.implementation.matching_guards_in(guards)
+        str = "WatirSpec guards for this implementation: \n"
+
+        if gs.empty?
+          "\tnone."
+        else
+          gs.each do |guard|
+            guard[:data][:file] = guard[:data][:file][%r{/spec/(.*):}, 1]
+            guard_name = "#{guard[:name]}:".ljust(15)
+            str << " \t#{guard_name} #{guard[:data].inspect}\n"
+          end
+          Watir.logger.warn str, id: [:guard_names]
+        end
+      end
+    end # class << self
+
+    private
+
+    def deviates_on(*impls)
+      Guards.record :deviates, impls, file: caller(1..1).first
+      return yield if WatirSpec.unguarded?
+
+      yield if WatirSpec.implementation.matches_guard?(impls)
+    end
+
+    def not_compliant_on(*impls)
+      Guards.record :not_compliant, impls, file: caller(1..1).first
+      return yield if WatirSpec.unguarded?
+
+      yield unless WatirSpec.implementation.matches_guard?(impls)
+    end
+
+    def compliant_on(*impls)
+      Guards.record :compliant, impls, file: caller(1..1).first
+      return yield if WatirSpec.unguarded?
+
+      yield if WatirSpec.implementation.matches_guard?(impls)
+    end
+
+    def bug(key, *impls)
+      Guards.record :bug, impls, file: caller(1..1).first, key: key
+      return yield if WatirSpec.unguarded?
+
+      yield if impls.any? && !WatirSpec.implementation.matches_guard?(impls)
+    end
+  end
+end
+
+class Object
+  include WatirSpec::Guards
+end

data/lib/watirspec/implementation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module WatirSpec
+  class Implementation
+    attr_writer :name, :guard_proc, :browser_class
+    attr_accessor :browser_args, :driver_info
+
+    def initialize
+      @guard_proc = nil
+    end
+
+    def initialize_copy(_orig)
+      @browser_args = browser_args.map(&:dup)
+    end
+
+    def browser_class
+      @browser_class || raise('browser_class not set')
+    end
+
+    def name
+      @name || raise('implementation name not set')
+    end
+
+    def browser_name
+      browser_args.first == :ie ? :internet_explorer : browser_args.first
+    end
+
+    def matches_guard?(args)
+      return @guard_proc.call(args) if @guard_proc
+
+      args.include? name
+    end
+
+    def matching_guards_in(guards)
+      result = []
+      guards.each { |args, data| data.each { |d| result << d } if args.empty? || matches_guard?(args) }
+
+      result
+    end
+
+    def inspect_args
+      selenium_opts = browser_args.last.dup
+
+      options = selenium_opts.delete(:options)
+      args = ["#{browser_args.first} tests:\n"]
+      selenium_opts.each { |opt| args << "#{opt.inspect}\n" }
+
+      return "#{browser_args.first} default options" if selenium_opts.empty? && options.nil?
+
+      args << "\toptions:\n"
+      options.each { |k, v| args << "\t\t#{k}: #{v}\n" }
+
+      args.join
+    end
+  end # Implementation
+end # WatirSpec

data/lib/watirspec/rake_tasks.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'rake/tasklib'
+
+module WatirSpec
+  class RakeTasks < Rake::TaskLib
+    def initialize
+      super
+
+      namespace :watirspec do
+        desc 'Initialize WatirSpec'
+        task :init do
+          init_watirspec
+          print_usage
+        end
+
+        desc 'List WatirSpec examples'
+        task :list do
+          print_specs
+        end
+
+        desc 'Run WatirSpec examples'
+        task :run, %i[spec line] do |_, args|
+          run(args)
+        end
+      end
+    end
+
+    private
+
+    def init_watirspec
+      FileUtils.mkdir_p('spec')
+      return if File.exist?('spec/watirspec_helper.rb')
+
+      File.write('spec/watirspec_helper.rb', watirspec_helper_template)
+    end
+
+    def print_specs
+      puts "The following spec files are present:\n\n"
+      spec_files.each do |file|
+        filename = file.sub("#{watirspec_path}/", '')
+        puts "  #{filename}"
+      end
+    end
+
+    def run(**args)
+      return if system(rspec_command(args))
+
+      exit $CHILD_STATUS.exitstatus || 1
+    end
+
+    def rspec_command(**args)
+      cmd = [rspec_binary]
+      if args[:spec]
+        spec_file = spec_files.find { |file| file == "#{watirspec_path}/#{args[:spec]}_spec.rb" }
+        spec_file << ":#{args[:line]}" if args[:line]
+        cmd << spec_file
+      else
+        cmd << spec_files
+      end
+
+      cmd.join(' ')
+    end
+
+    def spec_files
+      Dir.glob("#{watirspec_path}/**/*_spec.rb")
+    end
+
+    def rspec_binary
+      rspec_path = Bundler.rubygems.find_name('rspec-core').first.full_gem_path
+      "#{rspec_path}/exe/rspec"
+    end
+
+    def watirspec_path
+      watir_path = Bundler.rubygems.find_name('watir').first.full_gem_path
+      "#{watir_path}/spec/watirspec"
+    end
+
+    def watirspec_helper_template
+      <<~RUBY
+        require 'watirspec'
+        # require your gems
+
+        WatirSpec.implementation do |watirspec|
+          # add WatirSpec implementation (see example below)
+          #
+          # watirspec.name = :watizzle
+          # watirspec.browser_class = Watir::Browser
+          # watirspec.browser_args = [:firefox, {}]
+          # watirspec.guard_proc = lambda do |args|
+          #   args.include?(:firefox)
+          # end
+        end
+
+        WatirSpec.run!
+      RUBY
+    end
+
+    def print_usage
+      p <<~PRINT_USAGE
+        File spec/watirspec_helper.rb is successfully created!
+        Please, check it and customize for your needs. Once done, you can start using WatirSpec.
+
+        Run all WatirSpec examples:
+          $ bundle exec rake watirspec:run
+
+        Run specific WatirSpec example:
+          $ bundle exec rake watirspec:run[elements/div]
+
+        Run WatirSpec example on a custom line:
+          $ bundle exec rake watirspec:run[elements/div, 50]
+
+        List all WatirSpec examples:
+          $ bundle exec rake watirspec:list
+      PRINT_USAGE
+    end
+  end
+end