capybara 3.3.1 → 3.4.0

data/lib/capybara/selector.rb

@@ -10,15 +10,15 @@ Capybara::Selector::FilterSet.add(:_field) do
   expression_filter(:name) { |xpath, val| xpath[XPath.attr(:name) == val] }
   expression_filter(:placeholder) { |xpath, val| xpath[XPath.attr(:placeholder) == val] }
 
-  describe do |checked: nil, unchecked: nil, disabled: nil, multiple: nil, **_options|
-    desc, states = +"", []
+  describe(:node_filters) do |checked: nil, unchecked: nil, disabled: nil, multiple: nil, **|
+    desc, states = +'', []
     states << 'checked' if checked || (unchecked == false)
     states << 'not checked' if unchecked || (checked == false)
     states << 'disabled' if disabled == true
     states << 'not disabled' if disabled == false
     desc << " that is #{states.join(' and ')}" unless states.empty?
-    desc << " with the multiple attribute" if multiple == true
-    desc << " without the multiple attribute" if multiple == false
+    desc << ' with the multiple attribute' if multiple == true
+    desc << ' without the multiple attribute' if multiple == false
     desc
   end
 end
@@ -58,26 +58,34 @@ Capybara.add_selector(:field) do
   node_filter(:with) do |node, with|
     with.is_a?(Regexp) ? node.value =~ with : node.value == with.to_s
   end
-  describe do |type: nil, **options|
-    desc = +""
+
+  describe_expression_filters do |type: nil, **options|
+    desc = +''
     (expression_filters.keys - [:type]).each { |ef| desc << " with #{ef} #{options[ef]}" if options.key?(ef) }
     desc << " of type #{type.inspect}" if type
-    desc << " with value #{options[:with].to_s.inspect}" if options.key?(:with)
     desc
   end
+
+  describe_node_filters do |**options|
+    " with value #{options[:with].to_s.inspect}" if options.key?(:with)
+  end
 end
 
 Capybara.add_selector(:fieldset) do
-  xpath(:legend) do |locator, legend: nil, **_options|
+  xpath(:legend) do |locator, legend: nil, **|
+    locator_matchers = (XPath.attr(:id) == locator.to_s) | XPath.child(:legend)[XPath.string.n.is(locator.to_s)]
+    locator_matchers |= XPath.attr(test_id) == locator if test_id
     xpath = XPath.descendant(:fieldset)
-    xpath = xpath[(XPath.attr(:id) == locator.to_s) | XPath.child(:legend)[XPath.string.n.is(locator.to_s)]] unless locator.nil?
+    xpath = xpath[locator_matchers] unless locator.nil?
     xpath = xpath[XPath.child(:legend)[XPath.string.n.is(legend)]] if legend
     xpath
   end
+
+  node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
 end
 
 Capybara.add_selector(:link) do
-  xpath(:title, :alt) do |locator, href: true, enable_aria_label: false, alt: nil, title: nil, **_options|
+  xpath(:title, :alt) do |locator, href: true, alt: nil, title: nil, **|
     xpath = XPath.descendant(:a)
     xpath = xpath[
               case href
@@ -99,6 +107,7 @@ Capybara.add_selector(:link) do
                   XPath.attr(:title).is(locator),
                   XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
       matchers << XPath.attr(:'aria-label').is(locator) if enable_aria_label
+      matchers << XPath.attr(test_id) == locator if test_id
       xpath = xpath[matchers.reduce(:|)]
     end
 
@@ -121,27 +130,33 @@ Capybara.add_selector(:link) do
     expr[mod]
   end
 
-  describe do |**options|
-    desc = +""
-    desc << " with href #{options[:href].inspect}" if options[:href]
-    desc << " with no href attribute" if options.fetch(:href, true).nil?
+  describe_expression_filters do |**options|
+    desc = +''
+    desc << " with href #{options[:href].inspect}" if options[:href] && !options[:href].is_a?(Regexp)
+    desc << ' with no href attribute' if options.fetch(:href, true).nil?
+    desc
+  end
+
+  describe_node_filters do |href: nil, **|
+    " with href matching #{href.inspect}" if href.is_a? Regexp
   end
 end
 
 Capybara.add_selector(:button) do
-  xpath(:value, :title, :type) do |locator, enable_aria_label: false, **options|
+  xpath(:value, :title, :type) do |locator, **options|
     input_btn_xpath = XPath.descendant(:input)[XPath.attr(:type).one_of('submit', 'reset', 'image', 'button')]
     btn_xpath = XPath.descendant(:button)
     image_btn_xpath = XPath.descendant(:input)[XPath.attr(:type) == 'image']
 
     unless locator.nil?
       locator = locator.to_s
-      locator_matches = XPath.attr(:id).equals(locator) | XPath.attr(:value).is(locator) | XPath.attr(:title).is(locator)
-      locator_matches |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
+      locator_matchers = XPath.attr(:id).equals(locator) | XPath.attr(:value).is(locator) | XPath.attr(:title).is(locator)
+      locator_matchers |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
+      locator_matchers |= XPath.attr(test_id) == locator if test_id
 
-      input_btn_xpath = input_btn_xpath[locator_matches]
+      input_btn_xpath = input_btn_xpath[locator_matchers]
 
-      btn_xpath = btn_xpath[locator_matches | XPath.string.n.is(locator) | XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
+      btn_xpath = btn_xpath[locator_matchers | XPath.string.n.is(locator) | XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
 
       alt_matches = XPath.attr(:alt).is(locator)
       alt_matches |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
@@ -157,27 +172,27 @@ Capybara.add_selector(:button) do
 
   node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| !(value ^ node.disabled?) }
 
-  describe do |disabled: nil, **options|
-    desc = +""
-    desc << " that is disabled" if disabled == true
-    desc << describe_all_expression_filters(options)
-    desc
+  describe_expression_filters
+  describe_node_filters do |disabled: nil, **|
+    ' that is disabled' if disabled == true
   end
 end
 
 Capybara.add_selector(:link_or_button) do
-  label "link or button"
+  label 'link or button'
   xpath do |locator, **options|
     self.class.all.values_at(:link, :button).map { |selector| selector.xpath.call(locator, options) }.reduce(:union)
   end
 
-  node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| node.tag_name == "a" || !(value ^ node.disabled?) }
+  node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| node.tag_name == 'a' || !(value ^ node.disabled?) }
 
-  describe { |disabled: nil, **_options| " that is disabled" if disabled == true }
+  describe_node_filters do |disabled: nil, **|
+    ' that is disabled' if disabled == true
+  end
 end
 
 Capybara.add_selector(:fillable_field) do
-  label "field"
+  label 'field'
 
   xpath do |locator, **options|
     xpath = XPath.descendant(:input, :textarea)[!XPath.attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')]
@@ -186,7 +201,7 @@ Capybara.add_selector(:fillable_field) do
 
   expression_filter(:type) do |expr, type|
     type = type.to_s
-    if ['textarea'].include?(type)
+    if type == 'textarea'
       expr.self(type.to_sym)
     else
       expr[XPath.attr(:type) == type]
@@ -199,16 +214,14 @@ Capybara.add_selector(:fillable_field) do
     with.is_a?(Regexp) ? node.value =~ with : node.value == with.to_s
   end
 
-  describe do |options|
-    desc = +""
-    desc << describe_all_expression_filters(options)
-    desc << " with value #{options[:with].to_s.inspect}" if options.key?(:with)
-    desc
+  describe_expression_filters
+  describe_node_filters do |**options|
+    " with value #{options[:with].to_s.inspect}" if options.key?(:with)
   end
 end
 
 Capybara.add_selector(:radio_button) do
-  label "radio button"
+  label 'radio button'
 
   xpath do |locator, **options|
     xpath = XPath.descendant(:input)[XPath.attr(:type) == 'radio']
@@ -219,11 +232,9 @@ Capybara.add_selector(:radio_button) do
 
   node_filter(:option) { |node, value| node.value == value.to_s }
 
-  describe do |option: nil, **options|
-    desc = +""
-    desc << " with value #{option.inspect}" if option
-    desc << describe_all_expression_filters(options)
-    desc
+  describe_expression_filters
+  describe_node_filters do |option: nil, **|
+    " with value #{option.inspect}" if option
   end
 end
 
@@ -237,16 +248,14 @@ Capybara.add_selector(:checkbox) do
 
   node_filter(:option) { |node, value| node.value == value.to_s }
 
-  describe do |option: nil, **options|
-    desc = +""
-    desc << " with value #{option.inspect}" if option
-    desc << describe_all_expression_filters(options)
-    desc
+  describe_expression_filters
+  describe_node_filters do |option: nil, **|
+    " with value #{option.inspect}" if option
   end
 end
 
 Capybara.add_selector(:select) do
-  label "select box"
+  label 'select box'
 
   xpath do |locator, **options|
     xpath = XPath.descendant(:select)
@@ -280,19 +289,24 @@ Capybara.add_selector(:select) do
     (Array(selected) - actual).empty?
   end
 
-  describe do |options: nil, with_options: nil, selected: nil, with_selected: nil, **opts|
-    desc = +""
-    desc << " with options #{options.inspect}" if options
+  describe_expression_filters do |with_options: nil, **opts|
+    desc = +''
     desc << " with at least options #{with_options.inspect}" if with_options
+    desc << describe_all_expression_filters(opts)
+    desc
+  end
+
+  describe_node_filters do |options: nil, selected: nil, with_selected: nil, **|
+    desc = +''
+    desc << " with options #{options.inspect}" if options
     desc << " with #{selected.inspect} selected" if selected
     desc << " with at least #{with_selected.inspect} selected" if with_selected
-    desc << describe_all_expression_filters(opts)
     desc
   end
 end
 
 Capybara.add_selector(:datalist_input) do
-  label "input box with datalist completion"
+  label 'input box with datalist completion'
 
   xpath do |locator, **options|
     xpath = XPath.descendant(:input)[XPath.attr(:list)]
@@ -312,13 +326,16 @@ Capybara.add_selector(:datalist_input) do
     end
   end
 
-  describe do |options: nil, with_options: nil, **opts|
-    desc = +""
-    desc << " with options #{options.inspect}" if options
+  describe_expression_filters do |with_options: nil, **opts|
+    desc = +''
     desc << " with at least options #{with_options.inspect}" if with_options
     desc << describe_all_expression_filters(opts)
     desc
   end
+
+  describe_node_filters do |options: nil, **|
+    " with options #{options.inspect}" if options
+  end
 end
 
 Capybara.add_selector(:option) do
@@ -331,8 +348,8 @@ Capybara.add_selector(:option) do
   node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
   node_filter(:selected, :boolean) { |node, value| !(value ^ node.selected?) }
 
-  describe do |**options|
-    desc = +""
+  describe_node_filters do |**options|
+    desc = +''
     desc << " that is#{' not' unless options[:disabled]} disabled" if options.key?(:disabled)
     desc << " that is#{' not' unless options[:selected]} selected" if options.key?(:selected)
     desc
@@ -340,7 +357,7 @@ Capybara.add_selector(:option) do
 end
 
 Capybara.add_selector(:datalist_option) do
-  label "datalist option"
+  label 'datalist option'
   visible(:all)
 
   xpath do |locator|
@@ -351,15 +368,13 @@ Capybara.add_selector(:datalist_option) do
 
   node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
 
-  describe do |**options|
-    desc = +""
-    desc << " that is#{' not' unless options[:disabled]} disabled" if options.key?(:disabled)
-    desc
+  describe_node_filters do |**options|
+    " that is#{' not' unless options[:disabled]} disabled" if options.key?(:disabled)
   end
 end
 
 Capybara.add_selector(:file_field) do
-  label "file field"
+  label 'file field'
   xpath do |locator, options|
     xpath = XPath.descendant(:input)[XPath.attr(:type) == 'file']
     locate_field(xpath, locator, options)
@@ -367,18 +382,18 @@ Capybara.add_selector(:file_field) do
 
   filter_set(:_field, %i[disabled multiple name])
 
-  describe do |**options|
-    desc = +""
-    desc << describe_all_expression_filters(options)
-    desc
-  end
+  describe_expression_filters
 end
 
 Capybara.add_selector(:label) do
-  label "label"
+  label 'label'
   xpath(:for) do |locator, options|
     xpath = XPath.descendant(:label)
-    xpath = xpath[XPath.string.n.is(locator.to_s) | (XPath.attr(:id) == locator.to_s)] unless locator.nil?
+    unless locator.nil?
+      locator_matchers = XPath.string.n.is(locator.to_s) | (XPath.attr(:id) == locator.to_s)
+      locator_matchers |= XPath.attr(test_id) == locator if test_id
+      xpath = xpath[locator_matchers]
+    end
     if options.key?(:for) && !options[:for].is_a?(Capybara::Node::Element)
       with_attr = XPath.attr(:for) == options[:for].to_s
       labelable_elements = %i[button input keygen meter output progress select textarea]
@@ -401,45 +416,50 @@ Capybara.add_selector(:label) do
     end
   end
 
-  describe do |**options|
-    desc = +""
-    desc << " for #{options[:for]}" if options[:for]
-    desc
+  describe_expression_filters do |**options|
+    " for element with id of \"#{options[:for]}\"" if options.key?(:for) && !options[:for].is_a?(Capybara::Node::Element)
+  end
+  describe_node_filters do |**options|
+    " for element #{options[:for]}" if options[:for]&.is_a?(Capybara::Node::Element)
   end
 end
 
 Capybara.add_selector(:table) do
-  xpath(:caption) do |locator, caption: nil, **_options|
+  xpath(:caption) do |locator, caption: nil, **|
     xpath = XPath.descendant(:table)
-    xpath = xpath[(XPath.attr(:id) == locator.to_s) | XPath.descendant(:caption).is(locator.to_s)] unless locator.nil?
+    unless locator.nil?
+      locator_matchers = (XPath.attr(:id) == locator.to_s) | XPath.descendant(:caption).is(locator.to_s)
+      locator_matchers |= XPath.attr(test_id) == locator if test_id
+      xpath = xpath[locator_matchers]
+    end
     xpath = xpath[XPath.descendant(:caption) == caption] if caption
     xpath
   end
 
-  describe do |caption: nil, **_options|
-    desc = +""
-    desc << " with caption #{caption}" if caption
-    desc
+  describe_expression_filters do |caption: nil, **|
+    " with caption \"#{caption}\"" if caption
   end
 end
 
 Capybara.add_selector(:frame) do
   xpath(:name) do |locator, **options|
     xpath = XPath.descendant(:iframe).union(XPath.descendant(:frame))
-    xpath = xpath[(XPath.attr(:id) == locator.to_s) | (XPath.attr(:name) == locator.to_s)] unless locator.nil?
+    unless locator.nil?
+      locator_matchers = (XPath.attr(:id) == locator.to_s) | (XPath.attr(:name) == locator.to_s)
+      locator_matchers |= XPath.attr(test_id) == locator if test_id
+      xpath = xpath[locator_matchers]
+    end
     xpath = expression_filters.keys.inject(xpath) { |memo, ef| memo[find_by_attr(ef, options[ef])] }
     xpath
   end
 
-  describe do |name: nil, **_options|
-    desc = +""
-    desc << " with name #{name}" if name
-    desc
+  describe_expression_filters do |name: nil, **|
+    " with name #{name}" if name
   end
 end
 
 Capybara.add_selector(:element) do
-  xpath do |locator, **_options|
+  xpath do |locator, **|
     XPath.descendant((locator || '@').to_sym)
   end
 
@@ -458,10 +478,6 @@ Capybara.add_selector(:element) do
     val.is_a?(Regexp) ? node[name] =~ val : true
   end
 
-  describe do |**options|
-    desc = +""
-    desc << describe_all_expression_filters(options)
-    desc
-  end
+  describe_expression_filters
 end
 # rubocop:enable Metrics/BlockLength

data/lib/capybara/selector/css.rb

@@ -5,7 +5,7 @@ module Capybara
     class CSS
       def self.escape(str)
         value = str.dup
-        out = +""
+        out = +''
         out << value.slice!(0...1) if value =~ /^[-_]/
         out << (value[0] =~ NMSTART ? value.slice!(0...1) : escape_char(value.slice!(0...1)))
         out << value.gsub(/[^a-zA-Z0-9_-]/) { |c| escape_char c }
@@ -13,7 +13,7 @@ module Capybara
       end
 
       def self.escape_char(c)
-        c =~ %r{[ -/:-~]} ? "\\#{c}" : format("\\%06x", c.ord)
+        c =~ %r{[ -/:-~]} ? "\\#{c}" : format('\\%06x', c.ord)
       end
 
       def self.split(css)
@@ -31,7 +31,7 @@ module Capybara
         def split(css)
           selectors = []
           StringIO.open(css) do |str|
-            selector = ""
+            selector = ''
             while (c = str.getc)
               case c
               when '['
@@ -44,7 +44,7 @@ module Capybara
                 selector += c + str.getc
               when ','
                 selectors << selector.strip
-                selector = ""
+                selector = ''
               else
                 selector += c
               end

data/lib/capybara/selector/filter_set.rb

@@ -5,13 +5,13 @@ require 'capybara/selector/filter'
 module Capybara
   class Selector
     class FilterSet
-      attr_reader :descriptions, :node_filters, :expression_filters
+      attr_reader :node_filters, :expression_filters
 
       def initialize(name, &block)
         @name = name
-        @descriptions = []
-        @expression_filters = {}
         @node_filters = {}
+        @expression_filters = {}
+        @descriptions = Hash.new { |h, k| h[k] = [] }
         instance_eval(&block)
       end
 
@@ -24,13 +24,43 @@ module Capybara
         add_filter(name, Filters::ExpressionFilter, *types_and_options, &block)
       end
 
-      def describe(&block)
-        descriptions.push block
+      def describe(what = nil, &block)
+        case what
+        when nil
+          undeclared_descriptions.push block
+        when :node_filters
+          node_filter_descriptions.push block
+        when :expression_filters
+          expression_filter_descriptions.push block
+        else
+          raise ArgumentError, 'Unknown description type'
+        end
       end
 
-      def description(**options)
+      def description(node_filters: true, expression_filters: true, **options)
         opts = options_with_defaults(options)
-        @descriptions.map { |desc| desc.call(opts).to_s }.join
+        d = +''
+        d += undeclared_descriptions.map { |desc| desc.call(opts).to_s }.join
+        d += expression_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if expression_filters
+        d += node_filter_descriptions.map { |desc| desc.call(opts).to_s }.join if node_filters
+        d
+      end
+
+      def descriptions
+        warn 'DEPRECATED: FilterSet#descriptions is deprecated without replacement'
+        [undeclared_descriptions, node_filter_descriptions, expression_filter_descriptions].flatten
+      end
+
+      def import(name, filters = nil)
+        f_set = self.class.all[name]
+        filter_selector = filters.nil? ? ->(*) { true } : ->(n, _) { filters.include? n }
+
+        expression_filters.merge!(f_set.expression_filters.select(&filter_selector))
+        node_filters.merge!(f_set.node_filters.select(&filter_selector))
+
+        f_set.undeclared_descriptions.each { |desc| describe(&desc) }
+        f_set.expression_filter_descriptions.each { |desc| describe(:expression_filters, &desc) }
+        f_set.node_filter_descriptions.each { |desc| describe(:node_filters, &desc) }
       end
 
       class << self
@@ -47,6 +77,20 @@ module Capybara
         end
       end
 
+    protected
+
+      def undeclared_descriptions
+        @descriptions[:undeclared]
+      end
+
+      def node_filter_descriptions
+        @descriptions[:node_filters]
+      end
+
+      def expression_filter_descriptions
+        @descriptions[:expression_filters]
+      end
+
     private
 
       def options_with_defaults(options)
@@ -61,7 +105,7 @@ module Capybara
 
       def add_filter(name, filter_class, *types, matcher: nil, **options, &block)
         types.each { |k| options[k] = true }
-        raise "ArgumentError", ":default option is not supported for filters with a :matcher option" if matcher && options[:default]
+        raise 'ArgumentError', ':default option is not supported for filters with a :matcher option' if matcher && options[:default]
         if filter_class <= Filters::ExpressionFilter
           @expression_filters[name] = filter_class.new(name, matcher, block, options)
         else