selenium-webdriver 4.1.0 → 4.7.1

data/lib/selenium/webdriver/common/interactions/pointer_input.rb

@@ -20,6 +20,12 @@
 module Selenium
   module WebDriver
     module Interactions
+      #
+      # Creates actions specific to Pointer Input devices
+      #
+      # @api private
+      #
+
       class PointerInput < InputDevice
         KIND = {mouse: :mouse, pen: :pen, touch: :touch}.freeze
 
@@ -28,17 +34,12 @@ module Selenium
         def initialize(kind, name: nil)
           super(name)
           @kind = assert_kind(kind)
-        end
-
-        def type
-          Interactions::POINTER
+          @type = Interactions::POINTER
         end
 
         def encode
-          return nil if no_actions?
-
-          output = {type: type, id: name, actions: @actions.map(&:encode)}
-          output[:parameters] = {pointerType: kind}
+          output = super
+          output[:parameters] = {pointerType: kind} if output
           output
         end
 
@@ -48,92 +49,22 @@ module Selenium
           KIND[pointer]
         end
 
-        def create_pointer_move(duration: 0, x: 0, y: 0, element: nil, origin: nil)
-          add_action(PointerMove.new(self, duration, x, y, element: element, origin: origin))
+        def create_pointer_move(duration: 0, x: 0, y: 0, origin: nil, **opts)
+          add_action(PointerMove.new(self, duration, x, y, origin: origin, **opts))
         end
 
-        def create_pointer_down(button)
-          add_action(PointerPress.new(self, :down, button))
+        def create_pointer_down(button, **opts)
+          add_action(PointerPress.new(self, :down, button, **opts))
         end
 
-        def create_pointer_up(button)
-          add_action(PointerPress.new(self, :up, button))
+        def create_pointer_up(button, **opts)
+          add_action(PointerPress.new(self, :up, button, **opts))
         end
 
         def create_pointer_cancel
           add_action(PointerCancel.new(self))
         end
       end # PointerInput
-
-      class PointerPress < Interaction
-        BUTTONS = {left: 0, middle: 1, right: 2}.freeze
-        DIRECTIONS = {down: :pointerDown, up: :pointerUp}.freeze
-
-        def initialize(source, direction, button)
-          super(source)
-          @direction = assert_direction(direction)
-          @button = assert_button(button)
-        end
-
-        def type
-          @direction
-        end
-
-        def assert_button(button)
-          if button.is_a? Symbol
-            raise TypeError, "#{button.inspect} is not a valid button!" unless BUTTONS.key? button
-
-            button = BUTTONS[button]
-          end
-          raise ArgumentError, 'Button number cannot be negative!' unless button >= 0
-
-          button
-        end
-
-        def assert_direction(direction)
-          raise TypeError, "#{direction.inspect} is not a valid button direction" unless DIRECTIONS.key? direction
-
-          DIRECTIONS[direction]
-        end
-
-        def encode
-          {type: type, button: @button}
-        end
-      end # PointerPress
-
-      class PointerMove < Interaction
-        VIEWPORT = :viewport
-        POINTER = :pointer
-        ORIGINS = [VIEWPORT, POINTER].freeze
-
-        def initialize(source, duration, x, y, element: nil, origin: nil)
-          super(source)
-          @duration = duration * 1000
-          @x_offset = x
-          @y_offset = y
-          @origin = element || origin
-        end
-
-        def type
-          :pointerMove
-        end
-
-        def encode
-          output = {type: type, duration: @duration.to_i, x: @x_offset, y: @y_offset}
-          output[:origin] = @origin
-          output
-        end
-      end # Move
-
-      class PointerCancel < Interaction
-        def type
-          :pointerCancel
-        end
-
-        def encode
-          {type: type}
-        end
-      end # Cancel
     end # Interactions
   end # WebDriver
 end # Selenium

data/lib/selenium/webdriver/common/interactions/pointer_move.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you 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.
+
+module Selenium
+  module WebDriver
+    module Interactions
+      #
+      # Action related to moving the pointer.
+      #
+      # @api private
+      #
+
+      class PointerMove < Interaction
+        include PointerEventProperties
+
+        VIEWPORT = :viewport
+        POINTER = :pointer
+        ORIGINS = [VIEWPORT, POINTER].freeze
+
+        def initialize(source, duration, x, y, element: nil, origin: nil, **opts)
+          super(source)
+          @duration = duration * 1000
+          @x_offset = x
+          @y_offset = y
+          @origin = element || origin || :viewport
+          @type = :pointerMove
+          @opts = opts
+        end
+
+        def assert_source(source)
+          raise TypeError, "#{source.type} is not a valid input type" unless source.is_a? PointerInput
+        end
+
+        def encode
+          process_opts.merge('type' => type.to_s,
+                             'duration' => @duration.to_i,
+                             'x' => @x_offset,
+                             'y' => @y_offset,
+                             'origin' => @origin)
+        end
+      end # PointerMove
+    end # Interactions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/interactions/pointer_press.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you 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.
+
+module Selenium
+  module WebDriver
+    module Interactions
+      #
+      # Actions related to clicking, tapping or pressing the pointer.
+      #
+      # @api private
+      #
+
+      class PointerPress < Interaction
+        include PointerEventProperties
+
+        BUTTONS = {left: 0,
+                   touch: 0,
+                   pen_contact: 0,
+                   middle: 1,
+                   right: 2,
+                   pen_barrel: 2,
+                   x1: 3,
+                   back: 3,
+                   x2: 4,
+                   forward: 4}.freeze
+        DIRECTIONS = {down: :pointerDown, up: :pointerUp}.freeze
+
+        def initialize(source, direction, button, **opts)
+          super(source)
+          @direction = assert_direction(direction)
+          @button = assert_button(button)
+          @type = @direction
+          @opts = opts
+        end
+
+        def encode
+          process_opts.merge('type' => type.to_s, 'button' => @button)
+        end
+
+        private
+
+        def assert_source(source)
+          raise TypeError, "#{source.type} is not a valid input type" unless source.is_a? PointerInput
+        end
+
+        def assert_button(button)
+          case button
+          when Symbol
+            raise ArgumentError, "#{button} is not a valid button!" unless BUTTONS.key? button
+
+            BUTTONS[button]
+          when Integer
+            raise ArgumentError, 'Button number cannot be negative!' if button.negative?
+
+            button
+          else
+            raise TypeError, "button must be a positive integer or one of #{BUTTONS.keys}, not #{button.class}"
+          end
+        end
+
+        def assert_direction(direction)
+          raise ArgumentError, "#{direction.inspect} is not a valid button direction" unless DIRECTIONS.key? direction
+
+          DIRECTIONS[direction]
+        end
+      end # PointerPress
+    end # Interactions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/interactions/scroll.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you 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.
+
+module Selenium
+  module WebDriver
+    module Interactions
+      #
+      # Action related to scrolling a wheel.
+      #
+      # @api private
+      #
+
+      class Scroll < Interaction
+        def initialize(source:, x: 0, y: 0, delta_x: 0, delta_y: 0, origin: :viewport, duration: 0.25)
+          super(source)
+          @type = :scroll
+          @duration = duration * 1000
+          @origin = origin
+          @x_offset = x
+          @y_offset = y
+          @delta_x = delta_x
+          @delta_y = delta_y
+        end
+
+        def assert_source(source)
+          raise TypeError, "#{source.type} is not a valid input type" unless source.is_a? WheelInput
+        end
+
+        def encode
+          {'type' => type.to_s,
+           'duration' => @duration.to_i,
+           'x' => @x_offset,
+           'y' => @y_offset,
+           'deltaX' => @delta_x,
+           'deltaY' => @delta_y,
+           'origin' => @origin.is_a?(Element) ? @origin : @origin.to_s}
+        end
+      end # PointerPress
+    end # Interactions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/interactions/scroll_origin.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you 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.
+
+module Selenium
+  module WebDriver
+    module WheelActions
+      class ScrollOrigin
+        class << self
+          def element(element, x_offset = 0, y_offset = 0)
+            new(element, x_offset, y_offset)
+          end
+
+          def viewport(x_offset = 0, y_offset = 0)
+            new(:viewport, x_offset, y_offset)
+          end
+        end
+
+        attr_reader :origin, :x_offset, :y_offset
+
+        #
+        # Use a static method to access
+        # @api private
+        #
+        def initialize(origin, x_offset, y_offset)
+          @origin = origin
+          @x_offset = x_offset
+          @y_offset = y_offset
+        end
+      end # ScrollOrigin
+    end # WheelActions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/interactions/typing_interaction.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you 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.
+
+module Selenium
+  module WebDriver
+    module Interactions
+      #
+      # Actions related to pressing keys.
+      #
+      # @api private
+      #
+
+      class TypingInteraction < Interaction
+        attr_reader :type
+
+        def initialize(source, type, key)
+          super(source)
+          @type = assert_type(type)
+          @key = Keys.encode_key(key)
+        end
+
+        def assert_source(source)
+          raise TypeError, "#{source.type} is not a valid input type" unless source.is_a? KeyInput
+        end
+
+        def assert_type(type)
+          raise TypeError, "#{type.inspect} is not a valid key subtype" unless KeyInput::SUBTYPES.key? type
+
+          KeyInput::SUBTYPES[type]
+        end
+
+        def encode
+          {type: @type, value: @key}
+        end
+      end # TypingInteraction
+    end # Interactions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/interactions/wheel_actions.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you 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.
+
+module Selenium
+  module WebDriver
+    module WheelActions
+      attr_writer :default_scroll_duration
+
+      #
+      # By default this is set to 250ms in the ActionBuilder constructor
+      # It can be overridden with default_scroll_duration=
+      #
+
+      def default_scroll_duration
+        @default_scroll_duration ||= @duration / 1000.0 # convert ms to seconds
+      end
+
+      #
+      # If the element is outside the viewport, scrolls the bottom of the element to the bottom of the viewport.
+      #
+      # @example Scroll to element
+      #    el = driver.find_element(id: "some_id")
+      #    driver.action.scroll_to(element).perform
+      #
+      # @param [Object] Which element to scroll into the viewport.
+      # @return [Selenium::WebDriver::WheelActions] A self reference.
+      def scroll_to(element, device: nil)
+        scroll(origin: element, device: device)
+      end
+
+      #
+      # Scrolls by provided amounts with the origin in the top left corner of the viewport.
+      #
+      # @example Scroll viewport by a specified amount
+      #    el = driver.find_element(id: "some_id")
+      #    driver.action.scroll_by(100, 200).perform
+      #
+      # @param [Integer] delta_x Distance along X axis to scroll using the wheel. A negative value scrolls left.
+      # @param [Integer] delta_y Distance along Y axis to scroll using the wheel. A negative value scrolls up.
+      # @return [Selenium::WebDriver::WheelActions] A self reference.
+      def scroll_by(delta_x, delta_y, device: nil)
+        scroll(delta_x: delta_x, delta_y: delta_y, device: device)
+      end
+
+      #
+      # Scrolls by provided amount based on a provided origin.
+      #
+      # The scroll origin is either the center of an element or the upper left of the viewport plus any offsets.
+      # If the origin is an element, and the element is not in the viewport, the bottom of the element will first
+      #   be scrolled to the bottom of the viewport.
+      #
+      # @example Scroll from element by a specified amount
+      #    el = driver.find_element(id: "some_id")
+      #    origin = WheelActions::ScrollOrigin.element(el)
+      #    driver.action.scroll_from(origin, 0, 200).perform
+      #
+      # @example Scroll from element by a specified amount with an offset
+      #    el = driver.find_element(id: "some_id")
+      #    origin = WheelActions::ScrollOrigin.element(el, 10, 10)
+      #    driver.action.scroll_from(origin, 100, 200).perform
+      #
+      # @example Scroll viewport by a specified amount with an offset
+      #    origin = WheelActions::ScrollOrigin.viewport(10, 10)
+      #    driver.action.scroll_from(origin, 0, 200).perform
+      #
+      # @param [ScrollOrigin] scroll_origin Where scroll originates (viewport or element center) plus provided offsets.
+      # @param [Integer] delta_x Distance along X axis to scroll using the wheel. A negative value scrolls left.
+      # @param [Integer] delta_y Distance along Y axis to scroll using the wheel. A negative value scrolls up.
+      # @return [Selenium::WebDriver::WheelActions] A self reference.
+      # @raise [Error::MoveTargetOutOfBoundsError] If the origin with offset is outside the viewport.
+      def scroll_from(scroll_origin, delta_x, delta_y, device: nil)
+        raise TypeError, "#{scroll_origin.inspect} isn't a valid ScrollOrigin" unless scroll_origin.is_a?(ScrollOrigin)
+
+        scroll(x: scroll_origin.x_offset,
+               y: scroll_origin.y_offset,
+               delta_x: delta_x,
+               delta_y: delta_y,
+               origin: scroll_origin.origin,
+               device: device)
+      end
+
+      private
+
+      def scroll(**opts)
+        opts[:duration] = default_scroll_duration
+        wheel = wheel_input(opts.delete(:device))
+        wheel.create_scroll(**opts)
+        tick(wheel)
+        self
+      end
+
+      def wheel_input(name = nil)
+        device(name: name, type: Interactions::WHEEL) || add_wheel_input('wheel')
+      end
+    end # WheelActions
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/common/interactions/wheel_input.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Licensed to the Software Freedom Conservancy (SFC) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The SFC licenses this file
+# to you 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.
+
+module Selenium
+  module WebDriver
+    module Interactions
+      #
+      # Creates actions specific to Pointer Input devices
+      #
+      # @api private
+      #
+
+      class WheelInput < InputDevice
+        def initialize(name = nil)
+          super(name)
+          @type = Interactions::WHEEL
+        end
+
+        def create_scroll(**opts)
+          opts[:source] = self
+          add_action(Scroll.new(**opts))
+        end
+      end # PointerInput
+    end # Interactions
+  end # WebDriver
+end # Selenium

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

@@ -90,6 +90,7 @@ module Selenium
         meta: "\ue03D",
         command: "\ue03D", # alias
         left_meta: "\ue03D", # alias
+        zenkaku_hankaku: "\uE040",
         right_shift: "\ue050",
         right_control: "\ue051",
         right_alt: "\ue052",

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

@@ -104,33 +104,6 @@ module Selenium
         @timeouts ||= Timeouts.new(@bridge)
       end
 
-      def logs
-        WebDriver.logger.deprecate('Manager#logs', 'Chrome::Driver#logs')
-        @logs ||= Logs.new(@bridge)
-      end
-
-      #
-      # @param type [Symbol] Supports two values: :tab and :window.
-      # @return [String] The value of the window handle
-      #
-      def new_window(type = :tab)
-        WebDriver.logger.deprecate('Manager#new_window', 'TargetLocator#new_window', id: :new_window) do
-          'e.g., `driver.switch_to.new_window(:tab)`'
-        end
-        case type
-        when :tab, :window
-          result = @bridge.new_window(type)
-          unless result.key?('handle')
-            raise UnknownError, "the driver did not return a handle. " \
-                                "The returned result: #{result.inspect}"
-          end
-          result['handle']
-        else
-          raise ArgumentError, "invalid argument for type. Got: '#{type.inspect}'. " \
-                               "Try :tab or :window"
-        end
-      end
-
       def window
         @window ||= Window.new(@bridge)
       end

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

@@ -66,17 +66,10 @@ module Selenium
 
       attr_accessor :options
 
-      def initialize(options: nil, **opts)
+      def initialize(**opts)
         self.class.set_capabilities
 
-        @options = if options
-                     WebDriver.logger.deprecate(":options as keyword for initializing #{self.class}",
-                                                "custom values directly in #new constructor",
-                                                id: :options_options)
-                     opts.merge(options)
-                   else
-                     opts
-                   end
+        @options = opts
         @options[:browser_name] = self.class::BROWSER
       end
 

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

@@ -78,6 +78,10 @@ module Selenium
         engine == :jruby
       end
 
+      def truffleruby?
+        engine == :truffleruby
+      end
+
       def ruby_version
         RUBY_VERSION
       end
@@ -104,8 +108,7 @@ module Selenium
       end
 
       def cygwin?
-        RUBY_PLATFORM =~ /cygwin/
-        !Regexp.last_match.nil?
+        RUBY_PLATFORM.include?('cygwin')
       end
 
       def null_device
@@ -177,9 +180,9 @@ module Selenium
 
       def find_in_program_files(*binary_names)
         paths = [
-          ENV['PROGRAMFILES'] || '\\Program Files',
-          ENV['ProgramFiles(x86)'] || '\\Program Files (x86)',
-          ENV['ProgramW6432'] || '\\Program Files'
+          ENV.fetch('PROGRAMFILES', '\\Program Files'),
+          ENV.fetch('ProgramFiles(x86)', '\\Program Files (x86)'),
+          ENV.fetch('ProgramW6432', '\\Program Files')
         ]
 
         paths.each do |root|