tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/selenium-webdriver-4.2.0/lib/selenium/server.rb

@@ -1,283 +0,0 @@
-# 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 'childprocess'
-require 'selenium/webdriver/common/socket_poller'
-require 'net/http'
-
-module Selenium
-  #
-  # Wraps the remote server jar
-  #
-  # Usage:
-  #
-  #   server = Selenium::Server.new('/path/to/selenium-server-standalone.jar')
-  #   server.start
-  #
-  # Automatically download the given version:
-  #
-  #   server = Selenium::Server.get '2.6.0'
-  #   server.start
-  #
-  # or the latest version:
-  #
-  #   server = Selenium::Server.get :latest
-  #   server.start
-  #
-  # Run the server in the background:
-  #
-  #   server = Selenium::Server.new(jar, :background => true)
-  #   server.start
-  #
-  # Add additional arguments:
-  #
-  #   server = Selenium::Server.new(jar)
-  #   server << ["--additional", "args"]
-  #   server.start
-  #
-
-  class Server
-    class Error < StandardError; end
-
-    CL_RESET = WebDriver::Platform.windows? ? '' : "\r\e[0K"
-
-    class << self
-      #
-      # Download the given version of the selenium-server jar and return instance
-      #
-      # @param [String, Symbol] required_version X.Y.Z defaults to ':latest'
-      # @param [Hash] opts
-      # @return [Selenium::Server]
-      #
-
-      def get(required_version = :latest, opts = {})
-        new(download(required_version), opts)
-      end
-
-      #
-      # Download the given version of the selenium-server jar and return location
-      #
-      # @param [String, Symbol] required_version X.Y.Z defaults to ':latest'
-      # @return [String] location of downloaded file
-      #
-
-      def download(required_version = :latest)
-        required_version = latest if required_version == :latest
-        download_file_name = "selenium-server-#{required_version}.jar"
-
-        return download_file_name if File.exist? download_file_name
-
-        begin
-          download_location = available_assets[download_file_name]['browser_download_url']
-          released = Net::HTTP.get_response(URI.parse(download_location))
-          redirected = URI.parse released.header['location']
-
-          File.open(download_file_name, 'wb') do |destination|
-            download_server(redirected, destination)
-          end
-        rescue StandardError
-          FileUtils.rm download_file_name if File.exist? download_file_name
-          raise
-        end
-
-        download_file_name
-      end
-
-      #
-      # Ask GitHub what the latest selenium-server version is.
-      #
-
-      def latest
-        @latest ||= begin
-          available = available_assets.keys.map { |key| key[/selenium-server-(\d+\.\d+\.\d+)\.jar/, 1] }
-          available.map { |asset| Gem::Version.new(asset) }.max.to_s
-        end
-      end
-
-      # @api private
-
-      def available_assets
-        @available_assets ||= net_http_start('api.github.com') do |http|
-          json = http.get('/repos/seleniumhq/selenium/releases').body
-          all_assets = JSON.parse(json).map { |release| release['assets'] }.flatten
-          server_assets = all_assets.select { |asset| asset['name'].match(/selenium-server-(\d+\.\d+\.\d+)\.jar/) }
-          server_assets.each_with_object({}) { |asset, hash| hash[asset.delete('name')] = asset }
-        end
-      end
-
-      def net_http_start(address, &block)
-        http_proxy = ENV.fetch('http_proxy', nil) || ENV.fetch('HTTP_PROXY', nil)
-        if http_proxy
-          http_proxy = "http://#{http_proxy}" unless http_proxy.start_with?('http://')
-          uri = URI.parse(http_proxy)
-
-          Net::HTTP.start(address, nil, uri.host, uri.port, &block)
-        else
-          Net::HTTP.start(address, use_ssl: true, &block)
-        end
-      end
-
-      def download_server(uri, destination)
-        net_http_start('github-releases.githubusercontent.com') do |http|
-          request = Net::HTTP::Get.new uri
-          resp = http.request(request) do |response|
-            total = response.content_length
-            progress = 0
-            segment_count = 0
-
-            response.read_body do |segment|
-              progress += segment.length
-              segment_count += 1
-
-              if (segment_count % 15).zero?
-                percent = progress.fdiv(total) * 100
-                print "#{CL_RESET}Downloading #{destination.path}: #{percent.to_i}% (#{progress} / #{total})"
-                segment_count = 0
-              end
-
-              destination.write(segment)
-            end
-          end
-
-          raise Error, "#{resp.code} for #{destination.path}" unless resp.is_a? Net::HTTPSuccess
-        end
-      end
-    end
-
-    #
-    # The Mode of the Server
-    # :standalone, #hub, #node
-    #
-
-    attr_accessor :role, :port, :timeout, :background, :log
-
-    #
-    # @param [String] jar Path to the server jar.
-    # @param [Hash] opts the options to create the server process with
-    #
-    # @option opts [Integer] :port Port the server should listen on (default: 4444).
-    # @option opts [Integer] :timeout Seconds to wait for server launch/shutdown (default: 30)
-    # @option opts [true,false] :background Run the server in the background (default: false)
-    # @option opts [true,false,String] :log Either a path to a log file,
-    #                                      or true to pass server log to stdout.
-    # @raise [Errno::ENOENT] if the jar file does not exist
-    #
-
-    def initialize(jar, opts = {})
-      raise Errno::ENOENT, jar unless File.exist?(jar)
-
-      @jar        = jar
-      @host       = '127.0.0.1'
-      @role       = opts.fetch(:role, 'standalone')
-      @port       = opts.fetch(:port, 4444)
-      @timeout    = opts.fetch(:timeout, 30)
-      @background = opts.fetch(:background, false)
-      @log        = opts[:log]
-      @log_file   = nil
-      @additional_args = []
-    end
-
-    def start
-      process.start
-      poll_for_service
-
-      process.wait unless @background
-    end
-
-    def stop
-      begin
-        Net::HTTP.get(@host, '/selenium-server/driver/?cmd=shutDownSeleniumServer', @port)
-      rescue Errno::ECONNREFUSED
-      end
-
-      stop_process if @process
-      poll_for_shutdown
-
-      @log_file&.close
-    end
-
-    def webdriver_url
-      "http://#{@host}:#{@port}/wd/hub"
-    end
-
-    def <<(arg)
-      if arg.is_a?(Array)
-        @additional_args += arg
-      else
-        @additional_args << arg.to_s
-      end
-    end
-
-    private
-
-    def stop_process
-      return unless @process.alive?
-
-      begin
-        @process.poll_for_exit(5)
-      rescue ChildProcess::TimeoutError
-        @process.stop
-      end
-    rescue Errno::ECHILD
-      # already dead
-    ensure
-      @process = nil
-    end
-
-    def process
-      @process ||= begin
-        # extract any additional_args that start with -D as options
-        properties = @additional_args.dup - @additional_args.delete_if { |arg| arg[/^-D/] }
-        args = ['-jar', @jar, @role, '--port', @port.to_s]
-        server_command = ['java'] + properties + args + @additional_args
-        cp = ChildProcess.build(*server_command)
-        WebDriver.logger.debug("Executing Process #{server_command}")
-
-        io = cp.io
-
-        if @log.is_a?(String)
-          @log_file = File.open(@log, 'w')
-          io.stdout = io.stderr = @log_file
-        elsif @log
-          io.inherit!
-        end
-
-        cp.detach = @background
-
-        cp
-      end
-    end
-
-    def poll_for_service
-      return if socket.connected?
-
-      raise Error, "remote server not launched in #{@timeout} seconds"
-    end
-
-    def poll_for_shutdown
-      return if socket.closed?
-
-      raise Error, "remote server not stopped in #{@timeout} seconds"
-    end
-
-    def socket
-      @socket ||= WebDriver::SocketPoller.new(@host, @port, @timeout)
-    end
-  end # Server
-end # Selenium

data/vendor/bundle/ruby/3.1.0/gems/selenium-webdriver-4.2.0/lib/selenium/webdriver/chrome/options.rb

@@ -1,261 +0,0 @@
-# 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 Chrome
-      class Options < WebDriver::Options
-        attr_accessor :profile, :logging_prefs
-
-        KEY = 'goog:chromeOptions'
-        BROWSER = 'chrome'
-
-        # see: http://chromedriver.chromium.org/capabilities
-        CAPABILITIES = {args: 'args',
-                        binary: 'binary',
-                        local_state: 'localState',
-                        prefs: 'prefs',
-                        detach: 'detach',
-                        debugger_address: 'debuggerAddress',
-                        exclude_switches: 'excludeSwitches',
-                        minidump_path: 'minidumpPath',
-                        emulation: 'mobileEmulation',
-                        perf_logging_prefs: 'perfLoggingPrefs',
-                        window_types: 'windowTypes',
-                        android_package: 'androidPackage',
-                        android_activity: 'androidActivity',
-                        android_device_serial: 'androidDeviceSerial',
-                        android_use_running_app: 'androidUseRunningApp'}.freeze
-
-        # NOTE: special handling of 'extensions' to validate when set instead of when used
-        attr_reader :extensions
-
-        # Create a new Options instance.
-        #
-        # @example
-        #   options = Selenium::WebDriver::Chrome::Options.new(args: ['start-maximized', 'user-data-dir=/tmp/temp_profile'])
-        #   driver = Selenium::WebDriver.for(:chrome, capabilities: options)
-        #
-        # @param [Profile] profile An instance of a Chrome::Profile Class
-        # @param [Hash] opts the pre-defined options to create the Chrome::Options with
-        # @option opts [Array] encoded_extensions List of extensions that do not need to be Base64 encoded
-        # @option opts [Array<String>] args List of command-line arguments to use when starting Chrome
-        # @option opts [String] binary Path to the Chrome executable to use
-        # @option opts [Hash] prefs A hash with each entry consisting of the name of the preference and its value
-        # @option opts [Array<String>] extensions A list of paths to (.crx) Chrome extensions to install on startup
-        # @option opts [Hash] options A hash for raw options
-        # @option opts [Hash] emulation A hash for raw emulation options
-        # @option opts [Hash] local_state A hash for the Local State file in the user data folder
-        # @option opts [Boolean] detach whether browser is closed when the driver is sent the quit command
-        # @option opts [String] debugger_address address of a Chrome debugger server to connect to
-        # @option opts [Array<String>] exclude_switches command line switches to exclude
-        # @option opts [String] minidump_path Directory to store Chrome minidumps (linux only)
-        # @option opts [Hash] perf_logging_prefs A hash for performance logging preferences
-        # @option opts [Array<String>] window_types A list of window types to appear in the list of window handles
-        #
-
-        def initialize(profile: nil, **opts)
-          super(**opts)
-
-          @profile = profile
-
-          @options = {args: [],
-                      prefs: {},
-                      emulation: {},
-                      extensions: [],
-                      local_state: {},
-                      exclude_switches: [],
-                      perf_logging_prefs: {},
-                      window_types: []}.merge(@options)
-
-          @logging_prefs = options.delete(:logging_prefs) || {}
-          @encoded_extensions = @options.delete(:encoded_extensions) || []
-          @extensions = []
-          @options.delete(:extensions).each { |ext| validate_extension(ext) }
-        end
-
-        #
-        # Add an extension by local path.
-        #
-        # @example
-        #   options = Selenium::WebDriver::Chrome::Options.new
-        #   options.add_extension('/path/to/extension.crx')
-        #
-        # @param [String] path The local path to the .crx file
-        #
-
-        def add_extension(path)
-          validate_extension(path)
-        end
-
-        #
-        # Add an extension by local path.
-        #
-        # @example
-        #   extensions = ['/path/to/extension.crx', '/path/to/other.crx']
-        #   options = Selenium::WebDriver::Chrome::Options.new
-        #   options.extensions = extensions
-        #
-        # @param [Array<String>] extensions A list of paths to (.crx) Chrome extensions to install on startup
-        #
-
-        def extensions=(extensions)
-          extensions.each { |ext| validate_extension(ext) }
-        end
-
-        #
-        # Add an extension by Base64-encoded string.
-        #
-        # @example
-        #   options = Selenium::WebDriver::Chrome::Options.new
-        #   options.add_encoded_extension(encoded_string)
-        #
-        # @param [String] encoded The Base64-encoded string of the .crx file
-        #
-
-        def add_encoded_extension(encoded)
-          @encoded_extensions << encoded
-        end
-
-        #
-        # Add a command-line argument to use when starting Chrome.
-        #
-        # @example Start Chrome maximized
-        #   options = Selenium::WebDriver::Chrome::Options.new
-        #   options.add_argument('start-maximized')
-        #
-        # @param [String] arg The command-line argument to add
-        #
-
-        def add_argument(arg)
-          @options[:args] << arg
-        end
-
-        #
-        # Add a preference that is only applied to the user profile in use.
-        #
-        # @example Set the default homepage
-        #   options = Selenium::WebDriver::Chrome::Options.new
-        #   options.add_preference('homepage', 'http://www.seleniumhq.com/')
-        #
-        # @param [String] name Key of the preference
-        # @param [Boolean, String, Integer] value Value of the preference
-        #
-
-        def add_preference(name, value)
-          @options[:prefs][name] = value
-        end
-
-        #
-        # Run Chrome in headless mode.
-        #
-        # @example Enable headless mode
-        #   options = Selenium::WebDriver::Chrome::Options.new
-        #   options.headless!
-        #
-
-        def headless!
-          add_argument '--headless'
-        end
-
-        #
-        # Add emulation device information
-        #
-        # see: http://chromedriver.chromium.org/mobile-emulation
-        #
-        # @example Start Chrome in mobile emulation mode by device name
-        #   options = Selenium::WebDriver::Chrome::Options.new
-        #   options.add_emulation(device_name: 'iPhone 6')
-        #
-        # @example Start Chrome in mobile emulation mode by device metrics
-        #   options = Selenium::WebDriver::Chrome::Options.new
-        #   options.add_emulation(device_metrics: {width: 400, height: 800, pixelRatio: 1, touch: true})
-        #
-        # @param [Hash] opts the pre-defined options for adding mobile emulation values
-        # @option opts [String] :device_name A valid device name from the Chrome DevTools Emulation panel
-        # @option opts [Hash] :device_metrics Hash containing width, height, pixelRatio, touch
-        # @option opts [String] :user_agent Full user agent
-        #
-
-        def add_emulation(**opts)
-          @options[:emulation] = opts
-        end
-
-        #
-        # Enables mobile browser use on Android.
-        #
-        # @see https://chromedriver.chromium.org/getting-started/getting-started---android
-        #
-        # @param [String] package The package name of the Chrome or WebView app.
-        # @param [String] serial_number The device serial number on which to launch the Chrome or WebView app.
-        # @param [String] use_running_app When true uses an already-running Chrome or WebView app,
-        #   instead of launching the app with a clear data directory.
-        # @param [String] activity Name of the Activity hosting the WebView (Not available on Chrome Apps).
-        #
-
-        def enable_android(package: 'com.android.chrome', serial_number: nil, use_running_app: nil, activity: nil)
-          @options[:android_package] = package
-          @options[:android_activity] = activity unless activity.nil?
-          @options[:android_device_serial] = serial_number unless serial_number.nil?
-          @options[:android_use_running_app] = use_running_app unless use_running_app.nil?
-        end
-
-        private
-
-        def enable_logging(browser_options)
-          browser_options['goog:loggingPrefs'] = @logging_prefs
-        end
-
-        def process_browser_options(browser_options)
-          enable_logging(browser_options) unless @logging_prefs.empty?
-
-          options = browser_options[self.class::KEY]
-          options['binary'] ||= binary_path if binary_path
-          if @profile
-            options['args'] ||= []
-            options['args'] << "--user-data-dir=#{@profile.directory}"
-          end
-
-          return if (@encoded_extensions + @extensions).empty?
-
-          options['extensions'] = @encoded_extensions + @extensions.map { |ext| encode_extension(ext) }
-        end
-
-        def binary_path
-          Chrome.path
-        end
-
-        def encode_extension(path)
-          File.open(path, 'rb') { |crx_file| Base64.strict_encode64 crx_file.read }
-        end
-
-        def validate_extension(path)
-          raise Error::WebDriverError, "could not find extension at #{path.inspect}" unless File.file?(path)
-          raise Error::WebDriverError, "file was not an extension #{path.inspect}" unless File.extname(path) == '.crx'
-
-          @extensions << path
-        end
-
-        def camelize?(key)
-          !%w[localState prefs].include?(key)
-        end
-      end # Options
-    end # Chrome
-  end # WebDriver
-end # Selenium

data/vendor/bundle/ruby/3.1.0/gems/selenium-webdriver-4.2.0/lib/selenium/webdriver/chrome.rb

@@ -1,55 +0,0 @@
-# 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 'net/http'
-
-module Selenium
-  module WebDriver
-    module Chrome
-      autoload :Features, 'selenium/webdriver/chrome/features'
-      autoload :Driver, 'selenium/webdriver/chrome/driver'
-      autoload :Profile, 'selenium/webdriver/chrome/profile'
-      autoload :Options, 'selenium/webdriver/chrome/options'
-      autoload :Service, 'selenium/webdriver/chrome/service'
-
-      def self.driver_path=(path)
-        WebDriver.logger.deprecate 'Selenium::WebDriver::Chrome#driver_path=',
-                                   'Selenium::WebDriver::Chrome::Service#driver_path=',
-                                   id: :driver_path
-        Selenium::WebDriver::Chrome::Service.driver_path = path
-      end
-
-      def self.driver_path
-        WebDriver.logger.deprecate 'Selenium::WebDriver::Chrome#driver_path',
-                                   'Selenium::WebDriver::Chrome::Service#driver_path',
-                                   id: :driver_path
-        Selenium::WebDriver::Chrome::Service.driver_path
-      end
-
-      def self.path=(path)
-        Platform.assert_executable path
-        @path = path
-      end
-
-      def self.path
-        @path ||= nil
-      end
-    end # Chrome
-  end # WebDriver
-end # Selenium