mega-max-rb 0.0.1

data/capybara-3.40.0/lib/capybara/node/simple.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Node
+    ##
+    #
+    # A {Capybara::Node::Simple} is a simpler version of {Capybara::Node::Base} which
+    # includes only {Capybara::Node::Finders} and {Capybara::Node::Matchers} and does
+    # not include {Capybara::Node::Actions}. This type of node is returned when
+    # using {Capybara.string}.
+    #
+    # It is useful in that it does not require a session, an application or a driver,
+    # but can still use Capybara's finders and matchers on any string that contains HTML.
+    #
+    class Simple
+      include Capybara::Node::Finders
+      include Capybara::Node::Matchers
+      include Capybara::Node::DocumentMatchers
+
+      attr_reader :native
+
+      def initialize(native)
+        native = Capybara::HTML(native) if native.is_a?(String)
+        @native = native
+      end
+
+      ##
+      #
+      # @return [String]    The text of the element
+      #
+      def text(_type = nil, normalize_ws: false)
+        txt = native.text
+        normalize_ws ? txt.gsub(/[[:space:]]+/, ' ').strip : txt
+      end
+
+      ##
+      #
+      # Retrieve the given attribute
+      #
+      #     element[:title] # => HTML title attribute
+      #
+      # @param  [Symbol] name  The attribute name to retrieve
+      # @return [String]       The value of the attribute
+      #
+      def [](name)
+        attr_name = name.to_s
+        if attr_name == 'value'
+          value
+        elsif (tag_name == 'input') && (native[:type] == 'checkbox') && (attr_name == 'checked')
+          native['checked'] == 'checked'
+        else
+          native[attr_name]
+        end
+      end
+
+      ##
+      #
+      # @return [String]      The tag name of the element
+      #
+      def tag_name
+        native.node_name
+      end
+
+      ##
+      #
+      # An XPath expression describing where on the page the element can be found
+      #
+      # @return [String]      An XPath expression
+      #
+      def path
+        native.path
+      end
+
+      ##
+      #
+      # @return [String]    The value of the form element
+      #
+      def value
+        if tag_name == 'textarea'
+          native['_capybara_raw_value']
+        elsif tag_name == 'select'
+          selected_options = find_xpath('.//option[@selected]')
+          if multiple?
+            selected_options.map(&method(:option_value))
+          else
+            option_value(selected_options.first || find_xpath('.//option').first)
+          end
+        elsif tag_name == 'input' && %w[radio checkbox].include?(native[:type])
+          native[:value] || 'on'
+        else
+          native[:value]
+        end
+      end
+
+      ##
+      #
+      # Whether or not the element is visible. Does not support CSS, so
+      # the result may be inaccurate.
+      #
+      # @param  [Boolean] check_ancestors  Whether to inherit visibility from ancestors
+      # @return [Boolean]     Whether the element is visible
+      #
+      def visible?(check_ancestors = true) # rubocop:disable Style/OptionalBooleanParameter
+        return false if (tag_name == 'input') && (native[:type] == 'hidden')
+        return false if tag_name == 'template'
+
+        if check_ancestors
+          !find_xpath(VISIBILITY_XPATH)
+        else
+          # No need for an xpath if only checking the current element
+          !(native.key?('hidden') ||
+            /display:\s?none/.match?(native[:style] || '') ||
+            %w[script head style].include?(tag_name))
+        end
+      end
+
+      ##
+      #
+      # Whether or not the element is checked.
+      #
+      # @return [Boolean]     Whether the element is checked
+      #
+      def checked?
+        native.has_attribute?('checked')
+      end
+
+      ##
+      #
+      # Whether or not the element is disabled.
+      #
+      # @return [Boolean]     Whether the element is disabled
+      def disabled?
+        native.has_attribute?('disabled') &&
+          %w[button input select textarea optgroup option menuitem fieldset].include?(tag_name)
+      end
+
+      ##
+      #
+      # Whether or not the element is selected.
+      #
+      # @return [Boolean]     Whether the element is selected
+      #
+      def selected?
+        native.has_attribute?('selected')
+      end
+
+      def multiple?
+        native.has_attribute?('multiple')
+      end
+
+      def readonly?
+        native.has_attribute?('readonly')
+      end
+
+      def synchronize(_seconds = nil)
+        yield # simple nodes don't need to wait
+      end
+
+      def allow_reload!(*)
+        # no op
+      end
+
+      ##
+      #
+      # @return [String]     The title of the document
+      def title
+        native.title
+      end
+
+      def inspect
+        %(#<Capybara::Node::Simple tag="#{tag_name}" path="#{path}">)
+      end
+
+      # @api private
+      def find_css(css, **_options)
+        native.css(css)
+      end
+
+      # @api private
+      def find_xpath(xpath, **_options)
+        native.xpath(xpath)
+      end
+
+      # @api private
+      def session_options
+        Capybara.session_options
+      end
+
+      # @api private
+      def initial_cache
+        {}
+      end
+
+      def ==(other)
+        eql?(other) || (other.respond_to?(:native) && native == other.native)
+      end
+
+    private
+
+      def option_value(option)
+        return nil if option.nil?
+
+        option[:value] || option.content
+      end
+
+      VISIBILITY_XPATH = XPath.generate do |x|
+        x.ancestor_or_self[
+          x.attr(:style)[x.contains('display:none') | x.contains('display: none')] |
+          x.attr(:hidden) |
+          x.qname.one_of('script', 'head') |
+          (~x.self(:summary) & XPath.parent(:details)[!XPath.attr(:open)])
+        ].boolean
+      end.to_s.freeze
+    end
+  end
+end

data/capybara-3.40.0/lib/capybara/node/whitespace_normalizer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Node
+    ##
+    #
+    # {Capybara::Node::WhitespaceNormalizer} provides methods that
+    # help to normalize the spacing of text content inside of
+    # {Capybara::Node::Element}s by removing various unicode
+    # spacing and directional markings.
+    #
+    module WhitespaceNormalizer
+      # Unicode for NBSP, or  
+      NON_BREAKING_SPACE = "\u00a0"
+      LINE_SEPERATOR = "\u2028"
+      PARAGRAPH_SEPERATOR = "\u2029"
+
+      # All spaces except for NBSP
+      BREAKING_SPACES = "[[:space:]&&[^#{NON_BREAKING_SPACE}]]".freeze
+
+      # Whitespace we want to substitute with plain spaces
+      SQUEEZED_SPACES = " \n\f\t\v#{LINE_SEPERATOR}#{PARAGRAPH_SEPERATOR}".freeze
+
+      # Any whitespace at the front of text
+      LEADING_SPACES = /\A#{BREAKING_SPACES}+/
+
+      # Any whitespace at the end of text
+      TRAILING_SPACES = /#{BREAKING_SPACES}+\z/
+
+      # "Invisible" space character
+      ZERO_WIDTH_SPACE = "\u200b"
+
+      # Signifies text is read left to right
+      LEFT_TO_RIGHT_MARK = "\u200e"
+
+      # Signifies text is read right to left
+      RIGHT_TO_LEFT_MARK = "\u200f"
+
+      # Characters we want to truncate from text
+      REMOVED_CHARACTERS = [ZERO_WIDTH_SPACE, LEFT_TO_RIGHT_MARK, RIGHT_TO_LEFT_MARK].join
+
+      # Matches multiple empty lines
+      EMPTY_LINES = /[\ \n]*\n[\ \n]*/
+
+      ##
+      #
+      # Normalizes the spacing of a node's text to be similar to
+      # what matchers might expect.
+      #
+      # @param text [String]
+      # @return [String]
+      #
+      def normalize_spacing(text)
+        text
+          .delete(REMOVED_CHARACTERS)
+          .tr(SQUEEZED_SPACES, ' ')
+          .squeeze(' ')
+          .sub(LEADING_SPACES, '')
+          .sub(TRAILING_SPACES, '')
+          .tr(NON_BREAKING_SPACE, ' ')
+      end
+
+      ##
+      #
+      # Variant on {Capybara::Node::Normalizer#normalize_spacing} that
+      # targets the whitespace of visible elements only.
+      #
+      # @param text [String]
+      # @return [String]
+      #
+      def normalize_visible_spacing(text)
+        text
+          .squeeze(' ')
+          .gsub(EMPTY_LINES, "\n")
+          .sub(LEADING_SPACES, '')
+          .sub(TRAILING_SPACES, '')
+          .tr(NON_BREAKING_SPACE, ' ')
+      end
+    end
+  end
+end

data/capybara-3.40.0/lib/capybara/queries/active_element_query.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Capybara
+  # @api private
+  module Queries
+    class ActiveElementQuery < BaseQuery
+      def initialize(**options)
+        @options = options
+        super(@options)
+      end
+
+      def resolve_for(session)
+        node = session.driver.active_element
+        [Capybara::Node::Element.new(session, node, nil, self)]
+      end
+    end
+  end
+end

data/capybara-3.40.0/lib/capybara/queries/ancestor_query.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Queries
+    class AncestorQuery < Capybara::Queries::SelectorQuery
+      # @api private
+      def resolve_for(node, exact = nil)
+        @child_node = node
+
+        node.synchronize do
+          scope = node.respond_to?(:session) ? node.session.current_scope : node.find(:xpath, '/*')
+          match_results = super(scope, exact)
+          ancestors = node.find_xpath(XPath.ancestor.to_s)
+                          .map(&method(:to_element))
+                          .select { |el| match_results.include?(el) }
+          Capybara::Result.new(ordered_results(ancestors), self)
+        end
+      end
+
+      def description(applied = false) # rubocop:disable Style/OptionalBooleanParameter
+        child_query = @child_node&.instance_variable_get(:@query)
+        desc = super
+        desc += " that is an ancestor of #{child_query.description}" if child_query
+        desc
+      end
+    end
+  end
+end

data/capybara-3.40.0/lib/capybara/queries/base_query.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Capybara
+  # @api private
+  module Queries
+    class BaseQuery
+      COUNT_KEYS = %i[count minimum maximum between].freeze
+
+      attr_reader :options
+      attr_writer :session_options
+
+      def initialize(options)
+        @session_options = options.delete(:session_options)
+      end
+
+      def session_options
+        @session_options || Capybara.session_options
+      end
+
+      def wait
+        self.class.wait(options, session_options.default_max_wait_time)
+      end
+
+      def self.wait(options, default = Capybara.default_max_wait_time)
+        # if no value or nil for the :wait option is passed it should default to the default
+        wait = options.fetch(:wait, nil)
+        wait = default if wait.nil?
+        wait || 0
+      end
+
+      ##
+      #
+      # Checks if a count of 0 is valid for the query
+      # Returns false if query does not have any count options specified.
+      #
+      def expects_none?
+        count_specified? ? matches_count?(0) : false
+      end
+
+      ##
+      #
+      # Checks if the given count matches the query count options.
+      # Defaults to true if no count options are specified. If multiple
+      # count options exist, it tests that all conditions are met;
+      # however, if :count is specified, all other options are ignored.
+      #
+      # @param [Integer] count     The actual number. Should be coercible via Integer()
+      #
+      def matches_count?(count)
+        return (Integer(options[:count]) == count) if options[:count]
+        return false if options[:maximum] && (Integer(options[:maximum]) < count)
+        return false if options[:minimum] && (Integer(options[:minimum]) > count)
+        return false if options[:between] && !options[:between].include?(count)
+
+        true
+      end
+
+      ##
+      #
+      # Generates a failure message from the query description and count options.
+      #
+      def failure_message
+        +"expected to find #{description}" << count_message
+      end
+
+      def negative_failure_message
+        +"expected not to find #{description}" << count_message
+      end
+
+    private
+
+      def count_specified?
+        COUNT_KEYS.any? { |key| options.key? key }
+      end
+
+      def count_message
+        message = +''
+        count, between, maximum, minimum = options.values_at(:count, :between, :maximum, :minimum)
+        if count
+          message << " #{occurrences count}"
+        elsif between
+          message << " between #{between.begin ? between.first : 1} and " \
+                     "#{between.end ? between.last : 'infinite'} times"
+        elsif maximum
+          message << " at most #{occurrences maximum}"
+        elsif minimum
+          message << " at least #{occurrences minimum}"
+        end
+        message
+      end
+
+      def occurrences(count)
+        "#{count} #{Capybara::Helpers.declension('time', 'times', count)}"
+      end
+
+      def assert_valid_keys
+        invalid_keys = @options.keys - valid_keys
+        return if invalid_keys.empty?
+
+        invalid_names = invalid_keys.map(&:inspect).join(', ')
+        valid_names = valid_keys.map(&:inspect).join(', ')
+        raise ArgumentError, "Invalid option(s) #{invalid_names}, should be one of #{valid_names}"
+      end
+    end
+  end
+end

data/capybara-3.40.0/lib/capybara/queries/current_path_query.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'addressable/uri'
+
+module Capybara
+  # @api private
+  module Queries
+    class CurrentPathQuery < BaseQuery
+      def initialize(expected_path, **options, &optional_filter_block)
+        super(options)
+        @expected_path = expected_path
+        @options = {
+          url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || '').hostname.nil?,
+          ignore_query: false
+        }.merge(options)
+        @filter_block = optional_filter_block
+        assert_valid_keys
+      end
+
+      def resolves_for?(session)
+        uri = ::Addressable::URI.parse(session.current_url)
+        @actual_path = (options[:ignore_query] ? uri&.omit(:query) : uri).then do |u|
+          options[:url] ? u&.to_s : u&.request_uri
+        end
+
+        res = if @expected_path.is_a? Regexp
+          @actual_path.to_s.match?(@expected_path)
+        else
+          ::Addressable::URI.parse(@expected_path) == ::Addressable::URI.parse(@actual_path)
+        end
+
+        res && matches_filter_block?(uri)
+      end
+
+      def failure_message
+        failure_message_helper
+      end
+
+      def negative_failure_message
+        failure_message_helper(' not')
+      end
+
+    private
+
+      def matches_filter_block?(url)
+        return true unless @filter_block
+
+        @filter_block.call(url)
+      end
+
+      def failure_message_helper(negated = '')
+        verb = @expected_path.is_a?(Regexp) ? 'match' : 'equal'
+        "expected #{@actual_path.inspect}#{negated} to #{verb} #{@expected_path.inspect}"
+      end
+
+      def valid_keys
+        %i[wait url ignore_query]
+      end
+    end
+  end
+end

data/capybara-3.40.0/lib/capybara/queries/match_query.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Queries
+    class MatchQuery < Capybara::Queries::SelectorQuery
+      def visible
+        options.key?(:visible) ? super : :all
+      end
+
+    private
+
+      def assert_valid_keys
+        invalid_options = @options.keys & COUNT_KEYS
+        unless invalid_options.empty?
+          raise ArgumentError, "Match queries don't support quantity options. Invalid keys - #{invalid_options.join(', ')}"
+        end
+
+        super
+      end
+
+      def valid_keys
+        super - COUNT_KEYS
+      end
+    end
+  end
+end