capybara 2.5.0 → 2.18.0

data/lib/capybara/rspec/compound.rb

@@ -0,0 +1,95 @@
+module Capybara
+  module RSpecMatchers
+    module Compound
+      include ::RSpec::Matchers::Composable
+
+      def and(matcher)
+        Capybara::RSpecMatchers::Compound::And.new(self,matcher)
+      end
+
+      def and_then(matcher)
+        ::RSpec::Matchers::BuiltIn::Compound::And.new(self, matcher)
+      end
+
+      def or(matcher)
+        Capybara::RSpecMatchers::Compound::Or.new(self, matcher)
+      end
+
+
+      class CapybaraEvaluator
+        def initialize(actual, matcher_1, matcher_2)
+          @actual        = actual
+          @matcher_1     = matcher_1
+          @matcher_2     = matcher_2
+          @match_results = Hash.new { |h, matcher| h[matcher] = matcher.matches?(@actual) }
+        end
+
+        def matcher_matches?(matcher)
+          @match_results[matcher]
+        end
+
+        def reset
+          @match_results.clear
+        end
+      end
+
+      class And < ::RSpec::Matchers::BuiltIn::Compound::And
+
+      private
+
+        def match(_expected, actual)
+          @evaluator = CapybaraEvaluator.new(actual, matcher_1, matcher_2)
+          syncer = sync_element(actual)
+          begin
+            syncer.synchronize do
+              @evaluator.reset
+              raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].all?
+              true
+            end
+          rescue
+            false
+          end
+        end
+
+        def sync_element(el)
+          if el.respond_to? :synchronize
+            el
+          elsif el.respond_to? :current_scope
+            el.current_scope
+          else
+            Capybara.string(el)
+          end
+        end
+      end
+
+      class Or < ::RSpec::Matchers::BuiltIn::Compound::Or
+
+      private
+
+        def match(_expected, actual)
+          @evaluator = CapybaraEvaluator.new(actual, matcher_1, matcher_2)
+          syncer = sync_element(actual)
+          begin
+            syncer.synchronize do
+              @evaluator.reset
+              raise ::Capybara::ElementNotFound unless [matcher_1_matches?, matcher_2_matches?].any?
+              true
+            end
+          rescue
+            false
+          end
+        end
+
+        def sync_element(el)
+          if el.respond_to? :synchronize
+            el
+          elsif el.respond_to? :current_scope
+            el.current_scope
+          else
+            Capybara.string(el)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/features.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 if RSpec::Core::Version::STRING.to_f >= 3.0
-  RSpec.shared_context "Capybara Features", :capybara_feature => true do
+  RSpec.shared_context "Capybara Features", capybara_feature: true do
     instance_eval do
       alias background before
       alias given let
@@ -7,11 +8,20 @@ if RSpec::Core::Version::STRING.to_f >= 3.0
     end
   end
 
+  # ensure shared_context is included if default shared_context_metadata_behavior is changed
+  if RSpec::Core::Version::STRING.to_f >= 3.5
+    RSpec.configure do |config|
+      config.include_context "Capybara Features", capybara_feature: true
+    end
+  end
+
   RSpec.configure do |config|
-    config.alias_example_group_to :feature, :capybara_feature => true, :type => :feature
+    config.alias_example_group_to :feature, capybara_feature: true, type: :feature
+    config.alias_example_group_to :xfeature, capybara_feature: true, type: :feature, skip: "Temporarily disabled with xfeature"
+    config.alias_example_group_to :ffeature, capybara_feature: true, type: :feature, focus: true
     config.alias_example_to :scenario
-    config.alias_example_to :xscenario, :skip => "Temporarily disabled with xscenario"
-    config.alias_example_to :fscenario, :focus => true
+    config.alias_example_to :xscenario, skip: "Temporarily disabled with xscenario"
+    config.alias_example_to :fscenario, focus: true
   end
 else
   module Capybara
@@ -29,7 +39,6 @@ else
     end
   end
 
-
   def self.feature(*args, &block)
     options = if args.last.is_a?(Hash) then args.pop else {} end
     options[:capybara_feature] = true
@@ -41,5 +50,7 @@ else
     RSpec.describe(*args, &block)
   end
 
-  RSpec.configuration.include Capybara::Features, :capybara_feature => true
+  RSpec.configure do |config|
+    config.include(Capybara::Features, capybara_feature: true)
+  end
 end

data/lib/capybara/rspec/matcher_proxies.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+module Capybara
+  module RSpecMatcherProxies
+    def all(*args)
+      if defined?(::RSpec::Matchers::BuiltIn::All) && args.first.respond_to?(:matches?)
+        ::RSpec::Matchers::BuiltIn::All.new(*args)
+      else
+        find_all(*args)
+      end
+    end
+
+    def within(*args)
+      if block_given?
+        within_element(*args, &Proc.new)
+      else
+        be_within(*args)
+      end
+    end
+  end
+
+  module DSL
+    class <<self
+      remove_method :included
+
+      def included(base)
+        warn "including Capybara::DSL in the global scope is not recommended!" if base == Object
+
+        if defined?(::RSpec::Matchers) && base.include?(::RSpec::Matchers)
+          base.send(:include, ::Capybara::RSpecMatcherProxies)
+        end
+
+        super
+      end
+    end
+  end
+end
+
+if defined?(::RSpec::Matchers)
+  module  ::RSpec::Matchers
+    def self.included(base)
+      base.send(:include, ::Capybara::RSpecMatcherProxies) if base.include?(::Capybara::DSL)
+      super
+    end
+  end
+end

data/lib/capybara/rspec/matchers.rb

@@ -1,56 +1,145 @@
+# frozen_string_literal: true
 module Capybara
   module RSpecMatchers
     class Matcher
-      include ::RSpec::Matchers::Composable if defined?(::RSpec::Expectations::Version) && RSpec::Expectations::Version::STRING.to_f >= 3.0
+      if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.0'))
+        require 'capybara/rspec/compound'
+        include ::Capybara::RSpecMatchers::Compound
+      end
+
+      attr_reader :failure_message, :failure_message_when_negated
 
       def wrap(actual)
-        if actual.respond_to?("has_selector?")
+        @context_el = if actual.respond_to?("has_selector?")
           actual
         else
           Capybara.string(actual.to_s)
         end
       end
-    end
 
-    class HaveSelector < Matcher
-      attr_reader :failure_message, :failure_message_when_negated
+      # RSpec 2 compatibility:
+      def failure_message_for_should; failure_message end
+      def failure_message_for_should_not; failure_message_when_negated end
 
-      def initialize(*args)
-        @args = args
-      end
+      private
 
-      def matches?(actual)
-        wrap(actual).assert_selector(*@args)
+      def wrap_matches?(actual)
+        yield(wrap(actual))
       rescue Capybara::ExpectationNotMet => e
         @failure_message = e.message
         return false
       end
 
-      def does_not_match?(actual)
-        wrap(actual).assert_no_selector(*@args)
+      def wrap_does_not_match?(actual)
+        yield(wrap(actual))
       rescue Capybara::ExpectationNotMet => e
         @failure_message_when_negated = e.message
         return false
       end
 
+      def session_query_args
+        if @args.last.is_a? Hash
+          @args.last[:session_options] = session_options
+        else
+          @args.push(session_options: session_options)
+        end
+        @args
+      end
+
+      def session_options
+        @context_el ||= nil
+        if @context_el.respond_to? :session_options
+          @context_el.session_options
+        elsif @context_el.respond_to? :current_scope
+          @context_el.current_scope.session_options
+        else
+          Capybara.session_options
+        end
+      end
+    end
+
+    class HaveSelector < Matcher
+      def initialize(*args, &filter_block)
+        @args = args
+        @filter_block = filter_block
+      end
+
+      def matches?(actual)
+        wrap_matches?(actual){ |el| el.assert_selector(*@args, &@filter_block) }
+      end
+
+      def does_not_match?(actual)
+        wrap_does_not_match?(actual){ |el| el.assert_no_selector(*@args, &@filter_block) }
+      end
+
       def description
         "have #{query.description}"
       end
 
       def query
-        @query ||= Capybara::Query.new(*@args)
+        @query ||= Capybara::Queries::SelectorQuery.new(*session_query_args, &@filter_block)
       end
+    end
 
-      # RSpec 2 compatibility:
-      alias_method :failure_message_for_should, :failure_message
-      alias_method :failure_message_for_should_not, :failure_message_when_negated
+    class HaveAllSelectors < Matcher
+      def initialize(*args, &filter_block)
+        @args = args
+        @filter_block = filter_block
+      end
+
+      def matches?(actual)
+        wrap_matches?(actual){ |el| el.assert_all_of_selectors(*@args, &@filter_block) }
+      end
+
+      def does_not_match?(actual)
+        raise ArgumentError, "The have_all_selectors matcher does not support use with not_to/should_not"
+      end
+
+      def description
+        "have all selectors"
+      end
+    end
+
+    class HaveNoSelectors < Matcher
+      def initialize(*args, &filter_block)
+        @args = args
+        @filter_block = filter_block
+      end
+
+      def matches?(actual)
+        wrap_matches?(actual){ |el| el.assert_none_of_selectors(*@args, &@filter_block) }
+      end
+
+      def does_not_match?(actual)
+        raise ArgumentError, "The have_none_of_selectors matcher does not support use with not_to/should_not"
+      end
+
+      def description
+        "have no selectors"
+      end
+    end
+
+    class MatchSelector < HaveSelector
+      def matches?(actual)
+        wrap_matches?(actual) { |el| el.assert_matches_selector(*@args, &@filter_block) }
+      end
+
+      def does_not_match?(actual)
+        wrap_does_not_match?(actual) { |el| el.assert_not_matches_selector(*@args, &@filter_block) }
+      end
+
+      def description
+        "match #{query.description}"
+      end
+
+      def query
+        @query ||= Capybara::Queries::MatchQuery.new(*session_query_args, &@filter_block)
+      end
     end
 
     class HaveText < Matcher
       attr_reader :type, :content, :options
 
-      attr_reader :failure_message, :failure_message_when_negated
-
       def initialize(*args)
         @args = args.dup
 
@@ -61,17 +150,11 @@ module Capybara
       end
 
       def matches?(actual)
-        wrap(actual).assert_text(*@args)
-      rescue Capybara::ExpectationNotMet => e
-        @failure_message = e.message
-        return false
+        wrap_matches?(actual) { |el| el.assert_text(*@args) }
       end
 
       def does_not_match?(actual)
-        wrap(actual).assert_no_text(*@args)
-      rescue Capybara::ExpectationNotMet => e
-        @failure_message_when_negated = e.message
-        return false
+        wrap_does_not_match?(actual) { |el| el.assert_no_text(*@args) }
       end
 
       def description
@@ -82,17 +165,11 @@ module Capybara
         content = Capybara::Helpers.normalize_whitespace(content) unless content.is_a? Regexp
         content.inspect
       end
-
-      # RSpec 2 compatibility:
-      alias_method :failure_message_for_should, :failure_message
-      alias_method :failure_message_for_should_not, :failure_message_when_negated
     end
 
     class HaveTitle < Matcher
       attr_reader :title
 
-      attr_reader :failure_message, :failure_message_when_negated
-
       def initialize(*args)
         @args = args
 
@@ -101,33 +178,21 @@ module Capybara
       end
 
       def matches?(actual)
-        wrap(actual).assert_title(*@args)
-      rescue Capybara::ExpectationNotMet => e
-        @failure_message = e.message
-        return false
+        wrap_matches?(actual) { |el| el.assert_title(*@args) }
       end
 
       def does_not_match?(actual)
-        wrap(actual).assert_no_title(*@args)
-      rescue Capybara::ExpectationNotMet => e
-        @failure_message_when_negated = e.message
-        return false
+        wrap_does_not_match?(actual) { |el| el.assert_no_title(*@args) }
       end
 
       def description
         "have title #{title.inspect}"
       end
-
-      # RSpec 2 compatibility:
-      alias_method :failure_message_for_should, :failure_message
-      alias_method :failure_message_for_should_not, :failure_message_when_negated
     end
 
     class HaveCurrentPath < Matcher
       attr_reader :current_path
 
-      attr_reader :failure_message, :failure_message_when_negated
-
       def initialize(*args)
         @args = args
 
@@ -136,35 +201,26 @@ module Capybara
       end
 
       def matches?(actual)
-        wrap(actual).assert_current_path(*@args)
-      rescue Capybara::ExpectationNotMet => e
-        @failure_message = e.message
-        return false
+        wrap_matches?(actual) { |el| el.assert_current_path(*@args) }
       end
 
       def does_not_match?(actual)
-        wrap(actual).assert_no_current_path(*@args)
-      rescue Capybara::ExpectationNotMet => e
-        @failure_message_when_negated = e.message
-        return false
+        wrap_does_not_match?(actual) { |el| el.assert_no_current_path(*@args) }
       end
 
       def description
         "have current path #{current_path.inspect}"
       end
-
-      # RSpec 2 compatibility:
-      alias_method :failure_message_for_should, :failure_message
-      alias_method :failure_message_for_should_not, :failure_message_when_negated
     end
 
     class BecomeClosed
       def initialize(options)
-        @wait_time = Capybara::Query.new(options).wait
+        @options = options
       end
 
       def matches?(window)
         @window = window
+        @wait_time = Capybara::Queries::BaseQuery.wait(@options, window.session.config.default_max_wait_time)
         start_time = Capybara::Helpers.monotonic_time
         while window.exists?
           return false if (Capybara::Helpers.monotonic_time - start_time) > @wait_time
@@ -186,18 +242,58 @@ module Capybara
       alias_method :failure_message_for_should_not, :failure_message_when_negated
     end
 
-    def have_selector(*args)
-      HaveSelector.new(*args)
+    # RSpec matcher for whether the element(s) matching a given selector exist
+    # See {Capybara::Node::Matcher#assert_selector}
+    def have_selector(*args, &optional_filter_block)
+      HaveSelector.new(*args, &optional_filter_block)
+    end
+
+    # RSpec matcher for whether the element(s) matching a group of selectors exist
+    # See {Capybara::Node::Matcher#assert_all_of_selectors}
+    def have_all_of_selectors(*args, &optional_filter_block)
+      HaveAllSelectors.new(*args, &optional_filter_block)
+    end
+
+    # RSpec matcher for whether no element(s) matching a group of selectors exist
+    # See {Capybara::Node::Matcher#assert_none_of_selectors}
+    def have_none_of_selectors(*args, &optional_filter_block)
+      HaveNoSelectors.new(*args, &optional_filter_block)
+    end
+
+    # RSpec matcher for whether the current element matches a given selector
+    # See {Capybara::Node::Matchers#assert_matches_selector}
+    def match_selector(*args, &optional_filter_block)
+      MatchSelector.new(*args, &optional_filter_block)
+    end
+    # defined_negated_matcher was added in RSpec 3.1 - it's syntactic sugar only since a user can do
+    # expect(page).not_to match_selector, so not sure we really need to support not_match_selector for prior to RSpec 3.1
+    ::RSpec::Matchers.define_negated_matcher :not_match_selector, :match_selector if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.1'))
+
+
+    # RSpec matcher for whether elements(s) matching a given xpath selector exist
+    # See {Capybara::Node::Matchers#has_xpath?}
+    def have_xpath(xpath, options={}, &optional_filter_block)
+      HaveSelector.new(:xpath, xpath, options, &optional_filter_block)
+    end
+
+    # RSpec matcher for whether the current element matches a given xpath selector
+    def match_xpath(xpath, options={}, &optional_filter_block)
+      MatchSelector.new(:xpath, xpath, options, &optional_filter_block)
     end
 
-    def have_xpath(xpath, options={})
-      HaveSelector.new(:xpath, xpath, options)
+    # RSpec matcher for whether elements(s) matching a given css selector exist
+    # See {Capybara::Node::Matchers#has_css?}
+    def have_css(css, options={}, &optional_filter_block)
+      HaveSelector.new(:css, css, options, &optional_filter_block)
     end
 
-    def have_css(css, options={})
-      HaveSelector.new(:css, css, options)
+    # RSpec matcher for whether the current element matches a given css selector
+    def match_css(css, options={}, &optional_filter_block)
+      MatchSelector.new(:css, css, options, &optional_filter_block)
     end
 
+    # RSpec matcher for text on the page
+    # See {Capybara::SessionMatchers#assert_text}
     def have_text(*args)
       HaveText.new(*args)
     end
@@ -207,36 +303,59 @@ module Capybara
       HaveTitle.new(title, options)
     end
 
+    # RSpec matcher for the current path
+    # See {Capybara::SessionMatchers#assert_current_path}
     def have_current_path(path, options = {})
       HaveCurrentPath.new(path, options)
     end
 
-    def have_link(locator, options={})
-      HaveSelector.new(:link, locator, options)
+    # RSpec matcher for links
+    # See {Capybara::Node::Matchers#has_link?}
+    def have_link(locator=nil, options={}, &optional_filter_block)
+      locator, options = nil, locator if locator.is_a? Hash
+      HaveSelector.new(:link, locator, options, &optional_filter_block)
     end
 
-    def have_button(locator, options={})
-      HaveSelector.new(:button, locator, options)
+    # RSpec matcher for buttons
+    # See {Capybara::Node::Matchers#has_button?}
+    def have_button(locator=nil, options={}, &optional_filter_block)
+      locator, options = nil, locator if locator.is_a? Hash
+      HaveSelector.new(:button, locator, options, &optional_filter_block)
     end
 
-    def have_field(locator, options={})
-      HaveSelector.new(:field, locator, options)
+    # RSpec matcher for links
+    # See {Capybara::Node::Matchers#has_field?}
+    def have_field(locator=nil, options={}, &optional_filter_block)
+      locator, options = nil, locator if locator.is_a? Hash
+      HaveSelector.new(:field, locator, options, &optional_filter_block)
     end
 
-    def have_checked_field(locator, options={})
-      HaveSelector.new(:field, locator, options.merge(:checked => true))
+    # RSpec matcher for checked fields
+    # See {Capybara::Node::Matchers#has_checked_field?}
+    def have_checked_field(locator=nil, options={}, &optional_filter_block)
+      locator, options = nil, locator if locator.is_a? Hash
+      HaveSelector.new(:field, locator, options.merge(checked: true), &optional_filter_block)
     end
 
-    def have_unchecked_field(locator, options={})
-      HaveSelector.new(:field, locator, options.merge(:unchecked => true))
+    # RSpec matcher for unchecked fields
+    # See {Capybara::Node::Matchers#has_unchecked_field?}
+    def have_unchecked_field(locator=nil, options={}, &optional_filter_block)
+      locator, options = nil, locator if locator.is_a? Hash
+      HaveSelector.new(:field, locator, options.merge(unchecked: true), &optional_filter_block)
     end
 
-    def have_select(locator, options={})
-      HaveSelector.new(:select, locator, options)
+    # RSpec matcher for select elements
+    # See {Capybara::Node::Matchers#has_select?}
+    def have_select(locator=nil, options={}, &optional_filter_block)
+      locator, options = nil, locator if locator.is_a? Hash
+      HaveSelector.new(:select, locator, options, &optional_filter_block)
     end
 
-    def have_table(locator, options={})
-      HaveSelector.new(:table, locator, options)
+    # RSpec matcher for table elements
+    # See {Capybara::Node::Matchers#has_table?}
+    def have_table(locator=nil, options={}, &optional_filter_block)
+      locator, options = nil, locator if locator.is_a? Hash
+      HaveSelector.new(:table, locator, options, &optional_filter_block)
     end
 
     ##
@@ -249,4 +368,4 @@ module Capybara
       BecomeClosed.new(options)
     end
   end
-end
+end

data/lib/capybara/rspec.rb

@@ -1,8 +1,9 @@
-require 'capybara'
-require 'capybara/dsl'
+# frozen_string_literal: true
 require 'rspec/core'
+require 'capybara/dsl'
 require 'capybara/rspec/matchers'
 require 'capybara/rspec/features'
+require 'capybara/rspec/matcher_proxies'
 
 RSpec.configure do |config|
   config.include Capybara::DSL, :type => :feature
@@ -22,6 +23,7 @@ RSpec.configure do |config|
       Capybara.use_default_driver
     end
   end
+
   config.before do
     if self.class.include?(Capybara::DSL)
       example = fetch_current_example.call(self)

data/lib/capybara/selector/css.rb

@@ -0,0 +1,30 @@
+module Capybara
+  class Selector
+    class CSS
+      def self.escape(str)
+        out = String.new("")
+        value = str.dup
+        out << value.slice!(0...1) if value =~ /^[-_]/
+        out << if value[0] =~ NMSTART
+          value.slice!(0...1)
+        else
+          escape_char(value.slice!(0...1))
+        end
+        out << value.gsub(/[^a-zA-Z0-9_-]/) {|c| escape_char c}
+        out
+      end
+
+      def self.escape_char(c)
+        return "\\%06x" % c.ord() unless c =~ %r{[ -/:-~]}
+        "\\#{c}"
+      end
+
+      S = '\u{80}-\u{D7FF}\u{E000}-\u{FFFD}\u{10000}-\u{10FFFF}'
+      H = /[0-9a-fA-F]/
+      UNICODE  = /\\#{H}{1,6}[ \t\r\n\f]?/
+      NONASCII = /[#{S}]/
+      ESCAPE   = /#{UNICODE}|\\[ -~#{S}]/
+      NMSTART  = /[_a-zA-Z]|#{NONASCII}|#{ESCAPE}/
+    end
+  end
+end

data/lib/capybara/selector/filter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require 'capybara/selector/filters/node_filter'
+require 'capybara/selector/filters/expression_filter'
+
+module Capybara
+  class Selector
+    def self.const_missing(const_name)
+      case const_name
+      when :Filter
+        warn "DEPRECATED: Capybara::Selector::Filter is deprecated, please use Capybara::Selector::Filters::NodeFilter instead"
+        Filters::NodeFilter
+      when :ExpressionFilter
+        warn "DEPRECATED: Capybara::Selector::ExpressionFilter is deprecated, please use Capybara::Selector::Filters::ExpressionFilter instead"
+        Filters::ExpressionFilter
+      else
+        super
+      end
+    end
+  end
+end