capybara 1.1.4 → 2.0.0.beta2

data/lib/capybara/node/simple.rb

@@ -95,7 +95,7 @@ module Capybara
       # @return [Boolean]     Whether the element is visible
       #
       def visible?
-        native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none')]").size == 0
+        native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or name()='script' or name()='head']").size == 0
       end
 
       ##
@@ -118,22 +118,20 @@ module Capybara
         native[:selected]
       end
 
-      def allow_reload!
-        # no op
-      end
-
-      def without_wait
-        yield
+      def synchronize
+        yield # simple nodes don't need to wait
       end
 
-    protected
-
-      def find_in_base(selector, xpath)
-        native.xpath(xpath).map { |node| self.class.new(node) }
+      def allow_reload!
+        # no op
       end
 
-      def wait_until
-        yield # simple nodes don't need to wait
+      def all(*args)
+        query = Capybara::Query.new(*args)
+        elements = native.xpath(query.xpath).map do |node|
+          self.class.new(node)
+        end
+        Capybara::Result.new(elements, query)
       end
     end
   end

data/lib/capybara/query.rb

@@ -0,0 +1,78 @@
+module Capybara
+  class Query
+    attr_accessor :selector, :locator, :options, :xpath, :find, :negative
+
+    VALID_KEYS = [:text, :visible, :between, :count, :maximum, :minimum]
+
+    def initialize(*args)
+      @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
+
+      unless options.has_key?(:visible)
+        @options[:visible] = Capybara.ignore_hidden_elements
+      end
+
+      if args[1]
+        @selector = Selector.all[args[0]]
+        @locator = args[1]
+      else
+        @selector = Selector.all.values.find { |s| s.match?(args[0]) }
+        @locator = args[0]
+      end
+      @selector ||= Selector.all[Capybara.default_selector]
+
+      @xpath = @selector.call(@locator).to_s
+
+      assert_valid_keys!
+    end
+
+    def name; selector.name; end
+    def label; selector.label or selector.name; end
+
+    def description
+      @description = "#{label} #{locator.inspect}"
+      @description << " with text #{options[:text].inspect}" if options[:text]
+      @description
+    end
+
+    def matches_filters?(node)
+      if options[:text]
+        regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text])
+        return false if not node.text.match(regexp)
+      end
+      return false if options[:visible] and not node.visible?
+      selector.custom_filters.each do |name, block|
+        return false if options.has_key?(name) and not block.call(node, options[name])
+      end
+      true
+    end
+
+    def matches_count?(count)
+      case
+      when count.zero?
+        false
+      when options[:between]
+        options[:between] === count
+      when options[:count]
+        options[:count].to_i == count
+      when options[:maximum]
+        options[:maximum].to_i >= count
+      when options[:minimum]
+        options[:minimum].to_i <= count
+      else
+        count > 0
+      end
+    end
+
+  private
+
+    def assert_valid_keys!
+      valid_keys = VALID_KEYS + @selector.custom_filters.keys
+      invalid_keys = @options.keys - valid_keys
+      unless invalid_keys.empty?
+        invalid_names = invalid_keys.map(&:inspect).join(", ")
+        valid_names = valid_keys.map(&:inspect).join(", ")
+        raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
+      end
+    end
+  end
+end

data/lib/capybara/rack_test/browser.rb

@@ -18,35 +18,36 @@ class Capybara::RackTest::Browser
 
   def visit(path, attributes = {})
     reset_host!
-    process(:get, path, attributes)
-    follow_redirects!
+    process_and_follow_redirects(:get, path, attributes)
   end
 
   def submit(method, path, attributes)
     path = request_path if not path or path.empty?
-    process(method, path, attributes)
-    follow_redirects!
+    process_and_follow_redirects(method, path, attributes, {'HTTP_REFERER' => current_url})
   end
 
   def follow(method, path, attributes = {})
     return if path.gsub(/^#{request_path}/, '').start_with?('#')
-    process(method, path, attributes)
-    follow_redirects!
+    process_and_follow_redirects(method, path, attributes, {'HTTP_REFERER' => current_url})
   end
 
-  def follow_redirects!
-    5.times do
-      process(:get, last_response["Location"]) if last_response.redirect?
+  def process_and_follow_redirects(method, path, attributes = {}, env = {})
+    process(method, path, attributes, env)
+    if driver.follow_redirects?
+      driver.redirect_limit.times do
+        process(:get, last_response["Location"], {}, env) if last_response.redirect?
+      end
+      raise Capybara::InfiniteRedirectError, "redirected more than #{driver.redirect_limit} times, check for infinite redirects." if last_response.redirect?
     end
-    raise Capybara::InfiniteRedirectError, "redirected more than 5 times, check for infinite redirects." if last_response.redirect?
   end
 
-  def process(method, path, attributes = {})
+  def process(method, path, attributes = {}, env = {})
     new_uri = URI.parse(path)
-    current_uri = URI.parse(current_url)
+    method.downcase! unless method.is_a? Symbol
 
     if new_uri.host
-      @current_host = new_uri.scheme + '://' + new_uri.host
+      @current_host = "#{new_uri.scheme}://#{new_uri.host}"
+      @current_host << ":#{new_uri.port}" if new_uri.port != new_uri.default_port
     end
 
     if new_uri.relative?
@@ -59,7 +60,7 @@ class Capybara::RackTest::Browser
     end
 
     reset_cache!
-    send(method, path, attributes, env)
+    send(method, path, attributes, env.merge(options[:headers] || {}))
   end
 
   def current_url
@@ -91,7 +92,7 @@ class Capybara::RackTest::Browser
   def source
     last_response.body
   rescue Rack::Test::Error
-    nil
+    ""
   end
 
 protected
@@ -106,16 +107,4 @@ protected
   rescue Rack::Test::Error
     ""
   end
-
-  def env
-    env = {}
-    begin
-      env["HTTP_REFERER"] = last_request.url
-    rescue Rack::Test::Error
-      # no request yet
-    end
-    env.merge!(options[:headers]) if options[:headers]
-    env
-  end
-
 end

data/lib/capybara/rack_test/driver.rb

@@ -6,7 +6,9 @@ require 'cgi'
 
 class Capybara::RackTest::Driver < Capybara::Driver::Base
   DEFAULT_OPTIONS = {
-    :respect_data_method => true
+    :respect_data_method => false,
+    :follow_redirects => true,
+    :redirect_limit => 5
   }
   attr_reader :app, :options
 
@@ -20,6 +22,14 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
     @browser ||= Capybara::RackTest::Browser.new(self)
   end
 
+  def follow_redirects?
+    @options[:follow_redirects]
+  end
+
+  def redirect_limit
+    @options[:redirect_limit]
+  end
+
   def response
     browser.last_response
   end

data/lib/capybara/rack_test/node.rb

@@ -1,6 +1,6 @@
 class Capybara::RackTest::Node < Capybara::Driver::Node
   def text
-    native.text
+    unnormalized_text.strip.gsub(/\s+/, ' ')
   end
 
   def [](name)
@@ -84,6 +84,22 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
     native.xpath(locator).map { |n| self.class.new(driver, n) }
   end
 
+protected
+
+  def unnormalized_text
+    if !visible?
+      ''
+    elsif native.text?
+      native.text
+    elsif native.element?
+      native.children.map do |child|
+        Capybara::RackTest::Node.new(driver, child).unnormalized_text
+      end.join
+    else
+      ''
+    end
+  end
+
 private
 
   def string_node

data/lib/capybara/result.rb

@@ -0,0 +1,84 @@
+module Capybara
+  class Result
+    include Enumerable
+
+    def initialize(elements, query)
+      @elements = elements
+      @result = elements.select { |node| query.matches_filters?(node) }
+      @rest = @elements - @result
+      @query = query
+    end
+
+    def each(&block)
+      @result.each(&block)
+    end
+
+    def first
+      @result.first
+    end
+
+    def matches_count?
+      @query.matches_count?(@result.size)
+    end
+
+    def find!
+      raise find_error if @result.count != 1
+      @result.first
+    end
+
+    def size; @result.size; end
+    alias_method :length, :size
+    alias_method :count, :size
+
+    def find_error
+      if @result.count == 0
+        Capybara::ElementNotFound.new("Unable to find #{@query.description}")
+      elsif @result.count > 1
+        Capybara::Ambiguous.new("Ambiguous match, found #{size} elements matching #{@query.description}")
+      end
+    end
+
+    def failure_message
+      message = if @query.options[:count]
+        "expected #{@query.description} to be found #{@query.options[:count]} #{declension("time", "times", @query.options[:count])}"
+      elsif @query.options[:between]
+        "expected #{@query.description} to be found between #{@query.options[:between].first} and #{@query.options[:between].last} times"
+      elsif @query.options[:maximum]
+        "expected #{@query.description} to be found at most #{@query.options[:maximum]} #{declension("time", "times", @query.options[:maximum])}"
+      elsif @query.options[:minimum]
+        "expected #{@query.description} to be found at least #{@query.options[:minimum]} #{declension("time", "times", @query.options[:minimum])}"
+      else
+        "expected to find #{@query.description}"
+      end
+      if count > 0
+        message << ", found #{count} #{declension("match", "matches")}: " << @result.map(&:text).map(&:inspect).join(", ")
+      else
+        message << " but there were no matches"
+      end
+      unless @rest.empty?
+        elements = @rest.map(&:text).map(&:inspect).join(", ")
+        message << ". Also found " << elements << ", which matched the selector but not all filters."
+      end
+      message
+    end
+
+    def negative_failure_message
+      "expected not to find #{@query.description}, but there #{declension("was", "were")} #{count} #{declension("match", "matches")}"
+    end
+
+    def empty?
+      @result.empty?
+    end
+    def [](key); @result[key]; end
+
+  private
+
+    def declension(singular, plural, count=count)
+      if count == 1
+        singular
+      else
+        plural
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers.rb

@@ -6,35 +6,15 @@ module Capybara
       end
 
       def matches?(actual)
-        @actual = wrap(actual)
-        @actual.has_selector?(*@args)
+        wrap(actual).assert_selector(*@args)
       end
 
       def does_not_match?(actual)
-        @actual = wrap(actual)
-        @actual.has_no_selector?(*@args)
-      end
-
-      def failure_message_for_should
-        if normalized.failure_message
-          normalized.failure_message.call(@actual, normalized)
-        else
-          "expected #{selector_name} to return something"
-        end
-      end
-
-      def failure_message_for_should_not
-        "expected #{selector_name} not to return anything"
+        wrap(actual).assert_no_selector(*@args)
       end
 
       def description
-        "has #{selector_name}"
-      end
-
-      def selector_name
-        name = "#{normalized.name} #{normalized.locator.inspect}"
-        name << " with text #{normalized.options[:text].inspect}" if normalized.options[:text]
-        name
+        "have #{query.description}"
       end
 
       def wrap(actual)
@@ -45,55 +25,38 @@ module Capybara
         end
       end
 
-      def normalized
-        @normalized ||= Capybara::Selector.normalize(*@args)
+      def query
+        @query ||= Capybara::Query.new(*@args)
       end
     end
 
-    class HaveMatcher
-      attr_reader :name, :locator, :options, :failure_message, :actual
-
-      def initialize(name, locator, options={}, &block)
-        @name = name
-        @locator = locator
-        @options = options
-        @failure_message = block
-      end
+    class HaveText
+      attr_reader :text
 
-      def arguments
-        if options.empty? then [locator] else [locator, options] end
+      def initialize(text)
+        @text = text
       end
 
       def matches?(actual)
         @actual = wrap(actual)
-        @actual.send(:"has_#{name}?", *arguments)
+        @actual.has_text?(text)
       end
 
       def does_not_match?(actual)
         @actual = wrap(actual)
-        @actual.send(:"has_no_#{name}?", *arguments)
+        @actual.has_no_text?(text)
       end
 
       def failure_message_for_should
-        if failure_message
-          failure_message.call(actual, self)
-        else
-          "expected #{selector_name} to return something"
-        end
+        "expected there to be text #{text.inspect} in #{@actual.text.inspect}"
       end
 
       def failure_message_for_should_not
-        "expected #{selector_name} not to return anything"
+        "expected there not to be text #{text.inspect} in #{@actual.text.inspect}"
       end
 
       def description
-        "has #{selector_name}"
-      end
-
-      def selector_name
-        selector_name = "#{name} #{locator.inspect}"
-        selector_name << " with text #{options[:text].inspect}" if options[:text]
-        selector_name
+        "have text #{text.inspect}"
       end
 
       def wrap(actual)
@@ -110,45 +73,47 @@ module Capybara
     end
 
     def have_xpath(xpath, options={})
-      HaveMatcher.new(:xpath, xpath, options)
+      HaveSelector.new(:xpath, xpath, options)
     end
 
     def have_css(css, options={})
-      HaveMatcher.new(:css, css, options)
+      HaveSelector.new(:css, css, options)
     end
 
     def have_content(text)
-      HaveMatcher.new(:content, text.to_s) do |page, matcher|
-        %(expected there to be content #{matcher.locator.inspect} in #{page.text.inspect})
-      end
+      HaveText.new(text)
+    end
+
+    def have_text(text)
+      HaveText.new(text)
     end
 
     def have_link(locator, options={})
-      HaveMatcher.new(:link, locator, options)
+      HaveSelector.new(:link, locator, options)
     end
 
     def have_button(locator)
-      HaveMatcher.new(:button, locator)
+      HaveSelector.new(:button, locator)
     end
 
     def have_field(locator, options={})
-      HaveMatcher.new(:field, locator, options)
+      HaveSelector.new(:field, locator, options)
     end
 
     def have_checked_field(locator)
-      HaveMatcher.new(:checked_field, locator)
+      HaveSelector.new(:field, locator, :checked => true)
     end
 
     def have_unchecked_field(locator)
-      HaveMatcher.new(:unchecked_field, locator)
+      HaveSelector.new(:field, locator, :unchecked => true)
     end
 
     def have_select(locator, options={})
-      HaveMatcher.new(:select, locator, options)
+      HaveSelector.new(:select, locator, options)
     end
 
     def have_table(locator, options={})
-      HaveMatcher.new(:table, locator, options)
+      HaveSelector.new(:table, locator, options)
     end
   end
 end