tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/selenium-webdriver-4.4.0/lib/selenium/webdriver/common/options.rb

@@ -0,0 +1,177 @@
+# 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
+    class Options
+      W3C_OPTIONS = %i[browser_name browser_version platform_name accept_insecure_certs page_load_strategy proxy
+                       set_window_rect timeouts unhandled_prompt_behavior strict_file_interactability
+                       web_socket_url].freeze
+
+      class << self
+        attr_reader :driver_path
+
+        def chrome(**opts)
+          Chrome::Options.new(**opts)
+        end
+
+        def firefox(**opts)
+          Firefox::Options.new(**opts)
+        end
+
+        def ie(**opts)
+          IE::Options.new(**opts)
+        end
+        alias_method :internet_explorer, :ie
+
+        def edge(**opts)
+          Edge::Options.new(**opts)
+        end
+        alias_method :microsoftedge, :edge
+
+        def safari(**opts)
+          Safari::Options.new(**opts)
+        end
+
+        def set_capabilities
+          (W3C_OPTIONS + self::CAPABILITIES.keys).each do |key|
+            next if method_defined? key
+
+            define_method key do
+              @options[key]
+            end
+
+            define_method "#{key}=" do |value|
+              @options[key] = value
+            end
+          end
+        end
+      end
+
+      attr_accessor :options
+
+      def initialize(**opts)
+        self.class.set_capabilities
+
+        @options = opts
+        @options[:browser_name] = self.class::BROWSER
+      end
+
+      #
+      # Add a new option not yet handled by bindings.
+      #
+      # @example Leave Chrome open when chromedriver is killed
+      #   options = Selenium::WebDriver::Chrome::Options.new
+      #   options.add_option(:detach, true)
+      #
+      # @param [String, Symbol] name Name of the option
+      # @param [Boolean, String, Integer] value Value of the option
+      #
+
+      def add_option(name, value = nil)
+        @options[name.keys.first] = name.values.first if value.nil? && name.is_a?(Hash)
+        @options[name] = value
+      end
+
+      def ==(other)
+        return false unless other.is_a? self.class
+
+        as_json == other.as_json
+      end
+
+      alias_method :eql?, :==
+
+      #
+      # @api private
+      #
+
+      def as_json(*)
+        options = @options.dup
+
+        w3c_options = process_w3c_options(options)
+
+        self.class::CAPABILITIES.each do |capability_alias, capability_name|
+          capability_value = options.delete(capability_alias)
+          options[capability_name] = capability_value if !capability_value.nil? && !options.key?(capability_name)
+        end
+        browser_options = defined?(self.class::KEY) ? {self.class::KEY => options} : options
+
+        process_browser_options(browser_options)
+        generate_as_json(w3c_options.merge(browser_options))
+      end
+
+      private
+
+      def w3c?(key)
+        W3C_OPTIONS.include?(key) || key.to_s.include?(':')
+      end
+
+      def process_w3c_options(options)
+        w3c_options = options.select { |key, _val| w3c?(key) }
+        w3c_options[:unhandled_prompt_behavior] &&= w3c_options[:unhandled_prompt_behavior]&.to_s&.tr('_', ' ')
+        options.delete_if { |key, _val| w3c?(key) }
+        w3c_options
+      end
+
+      def process_browser_options(_browser_options)
+        nil
+      end
+
+      def camelize?(_key)
+        true
+      end
+
+      def generate_as_json(value, camelize_keys: true)
+        if value.is_a?(Hash)
+          process_json_hash(value, camelize_keys)
+        elsif value.respond_to?(:as_json)
+          value.as_json
+        elsif value.is_a?(Array)
+          value.map { |val| generate_as_json(val, camelize_keys: camelize_keys) }
+        elsif value.is_a?(Symbol)
+          value.to_s
+        else
+          value
+        end
+      end
+
+      def process_json_hash(value, camelize_keys)
+        value.each_with_object({}) do |(key, val), hash|
+          next if val.respond_to?(:empty?) && val.empty?
+
+          camelize = camelize_keys ? camelize?(key) : false
+          key = convert_json_key(key, camelize: camelize)
+          hash[key] = generate_as_json(val, camelize_keys: camelize)
+        end
+      end
+
+      def convert_json_key(key, camelize: true)
+        key = key.to_s if key.is_a?(Symbol)
+        key = camel_case(key) if camelize
+        return key if key.is_a?(String)
+
+        raise TypeError, "expected String or Symbol, got #{key.inspect}:#{key.class}"
+      end
+
+      def camel_case(str)
+        str.gsub(/_([a-z])/) { Regexp.last_match(1).upcase }
+      end
+    end # Options
+  end # WebDriver
+end # Selenium

data/vendor/bundle/ruby/3.1.0/gems/selenium-webdriver-4.4.0/lib/selenium/webdriver/common/takes_screenshot.rb

@@ -0,0 +1,66 @@
+# 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
+    #
+    # @api private
+    #
+    module TakesScreenshot
+      #
+      # Save a PNG screenshot of the viewport to the given path
+      #
+      # @api public
+      #
+
+      def save_screenshot(png_path, full_page: false)
+        extension = File.extname(png_path).downcase
+        if extension != '.png'
+          WebDriver.logger.warn "name used for saved screenshot does not match file type. " \
+                                "It should end with .png extension",
+                                id: :screenshot
+        end
+        File.open(png_path, 'wb') { |f| f << screenshot_as(:png, full_page: full_page) }
+      end
+
+      #
+      # Return a PNG screenshot in the given format as a string
+      #
+      # @param [:base64, :png] format
+      # @param [Boolean] full_page allows taking full page screenshots if supported
+      # @return String screenshot
+      #
+      # @api public
+
+      def screenshot_as(format, full_page: false)
+        case format
+        when :base64
+          full_page ? full_screenshot : screenshot
+        when :png
+          screenshot_as(:base64, full_page: full_page).unpack1('m')
+        else
+          raise Error::UnsupportedOperationError, "unsupported format: #{format.inspect}"
+        end
+      rescue NameError
+        raise Error::UnsupportedOperationError, "Full Page Screenshots are not supported for #{inspect}"
+      end
+
+    end # TakesScreenshot
+  end # WebDriver
+end # Selenium

data/vendor/bundle/ruby/3.1.0/gems/selenium-webdriver-4.4.0/lib/selenium/webdriver/common/virtual_authenticator/credential.rb

@@ -0,0 +1,83 @@
+# 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.
+
+#
+# A credential stored in a virtual authenticator.
+# @see https://w3c.github.io/webauthn/#credential-parameters
+#
+
+module Selenium
+  module WebDriver
+    class Credential
+      class << self
+        def resident(**opts)
+          Credential.new(resident_credential: true, **opts)
+        end
+
+        def non_resident(**opts)
+          Credential.new(resident_credential: false, **opts)
+        end
+
+        def encode(byte_array)
+          Base64.urlsafe_encode64(byte_array&.pack('C*'))
+        end
+
+        def decode(base64)
+          Base64.urlsafe_decode64(base64).unpack('C*')
+        end
+
+        def from_json(opts)
+          user_handle = opts['userHandle'] ? decode(opts['userHandle']) : nil
+          new(id: decode(opts["credentialId"]),
+              resident_credential: opts["isResidentCredential"],
+              rp_id: opts['rpId'],
+              private_key: opts['privateKey'],
+              sign_count: opts['signCount'],
+              user_handle: user_handle)
+        end
+      end
+
+      attr_reader :id, :resident_credential, :rp_id, :user_handle, :private_key, :sign_count
+      alias_method :resident_credential?, :resident_credential
+
+      def initialize(id:, resident_credential:, rp_id:, private_key:, user_handle: nil, sign_count: 0)
+        @id = id
+        @resident_credential = resident_credential
+        @rp_id = rp_id
+        @user_handle = user_handle
+        @private_key = private_key
+        @sign_count = sign_count
+      end
+
+      #
+      # @api private
+      #
+
+      def as_json(*)
+        credential_data = {'credentialId' => Credential.encode(id),
+                           'isResidentCredential' => resident_credential?,
+                           'rpId' => rp_id,
+                           'privateKey' => Credential.encode(private_key),
+                           'signCount' => sign_count}
+        credential_data['userHandle'] = Credential.encode(user_handle) if user_handle
+        credential_data
+      end
+    end # Credential
+  end # WebDriver
+end # Selenium

data/vendor/bundle/ruby/3.1.0/gems/selenium-webdriver-4.4.0/lib/selenium/webdriver/common/virtual_authenticator/virtual_authenticator.rb

@@ -0,0 +1,73 @@
+# 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
+    class VirtualAuthenticator
+
+      attr_reader :options
+
+      #
+      # api private
+      # Use `Driver#add_virtual_authenticator`
+      #
+
+      def initialize(bridge, authenticator_id, options)
+        @id = authenticator_id
+        @bridge = bridge
+        @options = options
+        @valid = true
+      end
+
+      def add_credential(credential)
+        credential = credential.as_json
+        @bridge.add_credential credential, @id
+      end
+
+      def credentials
+        credential_data = @bridge.credentials @id
+        credential_data.map do |cred|
+          Credential.from_json(cred)
+        end
+      end
+
+      def remove_credential(credential_id)
+        credential_id = Credential.encode(credential_id) if credential_id.instance_of?(Array)
+        @bridge.remove_credential credential_id, @id
+      end
+
+      def remove_all_credentials
+        @bridge.remove_all_credentials @id
+      end
+
+      def user_verified=(verified)
+        @bridge.user_verified verified, @id
+      end
+
+      def remove!
+        @bridge.remove_virtual_authenticator(@id)
+        @valid = false
+      end
+
+      def valid?
+        @valid
+      end
+    end # VirtualAuthenticator
+  end # WebDriver
+end # Selenium

data/vendor/bundle/ruby/3.1.0/gems/selenium-webdriver-4.4.0/lib/selenium/webdriver/common/virtual_authenticator/virtual_authenticator_options.rb

@@ -0,0 +1,62 @@
+# 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.
+
+#
+# Options for the creation of virtual authenticators.
+# @see http://w3c.github.io/webauthn/#sctn-automation
+#
+
+module Selenium
+  module WebDriver
+    class VirtualAuthenticatorOptions
+
+      PROTOCOL = {ctap2: "ctap2", u2f: "ctap1/u2f"}.freeze
+      TRANSPORT = {ble: "ble", usb: "usb", nfc: "nfc", internal: "internal"}.freeze
+
+      attr_accessor :protocol, :transport, :resident_key, :user_verification, :user_consenting, :user_verified
+      alias_method :resident_key?, :resident_key
+      alias_method :user_verification?, :user_verification
+      alias_method :user_consenting?, :user_consenting
+      alias_method :user_verified?, :user_verified
+
+      def initialize(protocol: :ctap2, transport: :usb, resident_key: false,
+                     user_verification: false, user_consenting: true, user_verified: false)
+        @protocol = protocol
+        @transport = transport
+        @resident_key = resident_key
+        @user_verification = user_verification
+        @user_consenting = user_consenting
+        @user_verified = user_verified
+      end
+
+      #
+      # @api private
+      #
+
+      def as_json(*)
+        {'protocol' => PROTOCOL[protocol],
+         'transport' => TRANSPORT[transport],
+         'hasResidentKey' => resident_key?,
+         'hasUserVerification' => user_verification?,
+         'isUserConsenting' => user_consenting?,
+         'isUserVerified' => user_verified?}
+      end
+    end # VirtualAuthenticatorOptions
+  end # WebDriver
+end # Selenium

data/vendor/bundle/ruby/3.1.0/gems/selenium-webdriver-4.4.0/lib/selenium/webdriver/common/websocket_connection.rb

@@ -0,0 +1,156 @@
+# 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.
+
+require 'websocket'
+
+module Selenium
+  module WebDriver
+    class WebSocketConnection
+      RESPONSE_WAIT_TIMEOUT = 30
+      RESPONSE_WAIT_INTERVAL = 0.1
+
+      MAX_LOG_MESSAGE_SIZE = 9999
+
+      def initialize(url:)
+        @callback_threads = ThreadGroup.new
+
+        @session_id = nil
+        @url = url
+
+        process_handshake
+        @socket_thread = attach_socket_listener
+      end
+
+      def close
+        @callback_threads.list.each(&:exit)
+        @socket_thread.exit
+        socket.close
+      end
+
+      def callbacks
+        @callbacks ||= Hash.new { |callbacks, event| callbacks[event] = [] }
+      end
+
+      def send_cmd(**payload)
+        id = next_id
+        data = payload.merge(id: id)
+        WebDriver.logger.debug "WebSocket -> #{data}"[...MAX_LOG_MESSAGE_SIZE]
+        data = JSON.generate(data)
+        out_frame = WebSocket::Frame::Outgoing::Client.new(version: ws.version, data: data, type: 'text')
+        socket.write(out_frame.to_s)
+
+        wait.until { messages.delete(id) }
+      end
+
+      private
+
+      # We should be thread-safe to use the hash without synchronization
+      # because its keys are WebSocket message identifiers and they should be
+      # unique within a devtools session.
+      def messages
+        @messages ||= {}
+      end
+
+      def process_handshake
+        socket.print(ws.to_s)
+        ws << socket.readpartial(1024)
+      end
+
+      def attach_socket_listener
+        Thread.new do
+          Thread.current.abort_on_exception = true
+          Thread.current.report_on_exception = false
+
+          until socket.eof?
+            incoming_frame << socket.readpartial(1024)
+
+            while (frame = incoming_frame.next)
+              message = process_frame(frame)
+              next unless message['method']
+
+              params = message['params']
+              callbacks[message['method']].each do |callback|
+                @callback_threads.add(callback_thread(params, &callback))
+              end
+            end
+          end
+        end
+      end
+
+      def incoming_frame
+        @incoming_frame ||= WebSocket::Frame::Incoming::Client.new(version: ws.version)
+      end
+
+      def process_frame(frame)
+        message = frame.to_s
+
+        # Firefox will periodically fail on unparsable empty frame
+        return {} if message.empty?
+
+        message = JSON.parse(message)
+        messages[message["id"]] = message
+        WebDriver.logger.debug "WebSocket <- #{message}"[...MAX_LOG_MESSAGE_SIZE]
+
+        message
+      end
+
+      def callback_thread(params)
+        Thread.new do
+          Thread.current.abort_on_exception = true
+
+          # We might end up blocked forever when we have an error in event.
+          # For example, if network interception event raises error,
+          # the browser will keep waiting for the request to be proceeded
+          # before returning back to the original thread. In this case,
+          # we should at least print the error.
+          Thread.current.report_on_exception = true
+
+          yield params
+        end
+      end
+
+      def wait
+        @wait ||= Wait.new(timeout: RESPONSE_WAIT_TIMEOUT, interval: RESPONSE_WAIT_INTERVAL)
+      end
+
+      def socket
+        @socket ||= if URI(@url).scheme == 'wss'
+                      socket = TCPSocket.new(ws.host, ws.port)
+                      socket = OpenSSL::SSL::SSLSocket.new(socket, OpenSSL::SSL::SSLContext.new)
+                      socket.sync_close = true
+                      socket.connect
+
+                      socket
+                    else
+                      TCPSocket.new(ws.host, ws.port)
+                    end
+      end
+
+      def ws
+        @ws ||= WebSocket::Handshake::Client.new(url: @url)
+      end
+
+      def next_id
+        @id ||= 0
+        @id += 1
+      end
+
+    end # BiDi
+  end # WebDriver
+end # Selenium