capybara 1.1.4 → 2.0.0

data/lib/capybara/rack_test/browser.rb

@@ -18,48 +18,45 @@ 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
-    end
+    new_uri.path = request_path if path.start_with?("?")
+    new_uri.path = request_path.sub(%r(/[^/]*$), '/') + new_uri.path unless new_uri.path.start_with?('/')
+    new_uri.scheme ||= @current_scheme
+    new_uri.host ||= @current_host
+    new_uri.port ||= @current_port unless new_uri.default_port == @current_port
 
-    if new_uri.relative?
-      if path.start_with?('?')
-        path = request_path + path
-      elsif not path.start_with?('/')
-        path = request_path.sub(%r(/[^/]*$), '/') + path
-      end
-      path = current_host + path
-    end
+    @current_scheme = new_uri.scheme
+    @current_host = new_uri.host
+    @current_port = new_uri.port
 
     reset_cache!
-    send(method, path, attributes, env)
+    send(method, new_uri.to_s, attributes, env.merge(options[:headers] || {}))
   end
 
   def current_url
@@ -69,14 +66,17 @@ class Capybara::RackTest::Browser
   end
 
   def reset_host!
-    @current_host = (Capybara.app_host || Capybara.default_host)
+    uri = URI.parse(Capybara.app_host || Capybara.default_host)
+    @current_scheme = uri.scheme
+    @current_host = uri.host
+    @current_port = uri.port
   end
 
   def reset_cache!
     @dom = nil
   end
 
-  def body
+  def html
     dom.to_xml
   end
 
@@ -91,7 +91,7 @@ class Capybara::RackTest::Browser
   def source
     last_response.body
   rescue Rack::Test::Error
-    nil
+    ""
   end
 
 protected
@@ -106,16 +106,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
@@ -56,8 +66,8 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
     browser.find(selector)
   end
 
-  def body
-    browser.body
+  def html
+    browser.html
   end
 
   def source

data/lib/capybara/rack_test/node.rb

@@ -1,6 +1,6 @@
 class Capybara::RackTest::Node < Capybara::Driver::Node
   def text
-    native.text
+    Capybara::Helpers.normalize_whitespace(unnormalized_text)
   end
 
   def [](name)
@@ -12,6 +12,9 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
   end
 
   def set(value)
+    if (Array === value) && !self[:multiple]
+      raise ArgumentError.new "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
+    end
     if tag_name == 'input' and type == 'radio'
       other_radios_xpath = XPath.generate { |x| x.anywhere(:input)[x.attr(:name).equals(self[:name])] }.to_s
       driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute("checked") }
@@ -29,7 +32,17 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
         # Firefox, allowing no input
         value = value[0...self[:maxlength].to_i]
       end
-      native['value'] = value.to_s
+      if Array === value #Assert multiple attribute is present
+        value.each do |v|
+          new_native = native.clone
+          new_native.remove_attribute('value')
+          native.add_next_sibling(new_native)
+          new_native['value'] = v.to_s
+        end
+        native.remove
+      else
+        native['value'] = value.to_s
+      end
     elsif tag_name == "textarea"
       native.content = value.to_s
     end
@@ -84,6 +97,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,72 @@
+require 'forwardable'
+
+module Capybara
+  class Result
+    include Enumerable
+    extend Forwardable
+
+    def initialize(elements, query)
+      @elements = elements
+      @result = elements.select { |node| query.matches_filters?(node) }
+      @rest = @elements - @result
+      @query = query
+    end
+
+    def_delegators :@result, :each, :[], :at, :size, :count, :length, :first, :last, :empty?
+
+    def matches_count?
+      @query.matches_count?(@result.size)
+    end
+
+    def find!
+      raise find_error if @result.size != 1
+      @result.first
+    end
+
+    def find_error
+      if @result.size == 0
+        Capybara::ElementNotFound.new("Unable to find #{@query.description}")
+      elsif @result.size > 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
+
+  private
+
+    def declension(singular, plural, count=count)
+      if count == 1
+        singular
+      else
+        plural
+      end
+    end
+  end
+end

data/lib/capybara/rspec/features.rb

@@ -4,6 +4,9 @@ module Capybara
       base.instance_eval do
         alias :background :before
         alias :scenario :it
+        alias :xscenario :xit
+        alias :given :let
+        alias :given! :let!
       end
     end
   end
@@ -12,7 +15,7 @@ end
 def self.feature(*args, &block)
   options = if args.last.is_a?(Hash) then args.pop else {} end
   options[:capybara_feature] = true
-  options[:type] = :request
+  options[:type] = :feature
   options[:caller] ||= caller
   args.push(options)
 

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
+    class HaveText
+      attr_reader :text
 
-      def initialize(name, locator, options={}, &block)
-        @name = name
-        @locator = locator
-        @options = options
-        @failure_message = block
-      end
-
-      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 #{format(text)} in #{format(@actual.text)}"
       end
 
       def failure_message_for_should_not
-        "expected #{selector_name} not to return anything"
+        "expected there not to be text #{format(text)} in #{format(@actual.text)}"
       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 #{format(text)}"
       end
 
       def wrap(actual)
@@ -103,6 +66,11 @@ module Capybara
           Capybara.string(actual.to_s)
         end
       end
+
+      def format(text)
+        text = Capybara::Helpers.normalize_whitespace(text) unless text.is_a? Regexp
+        text.inspect
+      end
     end
 
     def have_selector(*args)
@@ -110,45 +78,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

data/lib/capybara/rspec.rb

@@ -5,10 +5,8 @@ require 'capybara/rspec/matchers'
 require 'capybara/rspec/features'
 
 RSpec.configure do |config|
-  config.include Capybara::DSL, :type => :request
-  config.include Capybara::DSL, :type => :acceptance
-  config.include Capybara::RSpecMatchers, :type => :request
-  config.include Capybara::RSpecMatchers, :type => :acceptance
+  config.include Capybara::DSL, :type => :feature
+  config.include Capybara::RSpecMatchers, :type => :feature
   # The before and after blocks must run instantaneously, because Capybara
   # might not actually be used in all examples where it's included.
   config.after do
@@ -24,3 +22,8 @@ RSpec.configure do |config|
     end
   end
 end
+
+# Override default rack_test driver to respect data-method attributes.
+Capybara.register_driver :rack_test do |app|
+  Capybara::RackTest::Driver.new(app, :respect_data_method => true)
+end

data/lib/capybara/selector.rb

@@ -1,13 +1,7 @@
 module Capybara
   class Selector
-    attr_reader :name
+    attr_reader :name, :custom_filters
 
-    class Normalized
-      attr_accessor :selector, :locator, :options, :xpaths
-
-      def failure_message; selector.failure_message; end
-      def name; selector.name; end
-    end
 
     class << self
       def all
@@ -21,32 +15,13 @@ module Capybara
       def remove(name)
         all.delete(name.to_sym)
       end
-
-      def normalize(*args)
-        normalized = Normalized.new
-        normalized.options = if args.last.is_a?(Hash) then args.pop else {} end
-
-        if args[1]
-          normalized.selector = all[args[0]]
-          normalized.locator = args[1]
-        else
-          normalized.selector = all.values.find { |s| s.match?(args[0]) }
-          normalized.locator = args[0]
-        end
-        normalized.selector ||= all[Capybara.default_selector]
-
-        xpath = normalized.selector.call(normalized.locator)
-        if xpath.respond_to?(:to_xpaths)
-          normalized.xpaths = xpath.to_xpaths
-        else
-          normalized.xpaths = [xpath.to_s].flatten
-        end
-        normalized
-      end
     end
 
     def initialize(name, &block)
       @name = name
+      @custom_filters = {}
+      @match = nil
+      @failure_message = nil
       instance_eval(&block)
     end
 
@@ -55,14 +30,22 @@ module Capybara
       @xpath
     end
 
+    # Same as xpath, but wrap in XPath.css().
+    def css(&block)
+      if block
+        @xpath = xpath { |*args| XPath.css(block.call(*args)) }
+      end
+      @xpath
+    end
+
     def match(&block)
       @match = block if block
       @match
     end
 
-    def failure_message(&block)
-      @failure_message = block if block
-      @failure_message
+    def label(label=nil)
+      @label = label if label
+      @label
     end
 
     def call(locator)
@@ -72,6 +55,10 @@ module Capybara
     def match?(locator)
       @match and @match.call(locator)
     end
+
+    def filter(name, &block)
+      @custom_filters[name] = block
+    end
   end
 end
 
@@ -80,10 +67,86 @@ Capybara.add_selector(:xpath) do
 end
 
 Capybara.add_selector(:css) do
-  xpath { |css| XPath.css(css) }
+  css { |css| css }
 end
 
 Capybara.add_selector(:id) do
   xpath { |id| XPath.descendant[XPath.attr(:id) == id.to_s] }
-  match { |value| value.is_a?(Symbol) }
+end
+
+Capybara.add_selector(:field) do
+  xpath { |locator| XPath::HTML.field(locator) }
+  filter(:checked) { |node, value| not(value ^ node.checked?) }
+  filter(:unchecked) { |node, value| (value ^ node.checked?) }
+  filter(:with) { |node, with| node.value == with }
+  filter(:type) { |node, type| node[:type] == type }
+end
+
+Capybara.add_selector(:fieldset) do
+  xpath { |locator| XPath::HTML.fieldset(locator) }
+end
+
+Capybara.add_selector(:link_or_button) do
+  label "link or button"
+  xpath { |locator| XPath::HTML.link_or_button(locator) }
+end
+
+Capybara.add_selector(:link) do
+  xpath { |locator| XPath::HTML.link(locator) }
+  filter(:href) do |node, href|
+    node.first(:xpath, XPath.axis(:self)[XPath.attr(:href).equals(href.to_s)])
+  end
+end
+
+Capybara.add_selector(:button) do
+  xpath { |locator| XPath::HTML.button(locator) }
+end
+
+Capybara.add_selector(:fillable_field) do
+  label "field"
+  xpath { |locator| XPath::HTML.fillable_field(locator) }
+end
+
+Capybara.add_selector(:radio_button) do
+  label "radio button"
+  xpath { |locator| XPath::HTML.radio_button(locator) }
+  filter(:checked) { |node, value| not(value ^ node.checked?) }
+  filter(:unchecked) { |node, value| (value ^ node.checked?) }
+end
+
+Capybara.add_selector(:checkbox) do
+  xpath { |locator| XPath::HTML.checkbox(locator) }
+  filter(:checked) { |node, value| not(value ^ node.checked?) }
+  filter(:unchecked) { |node, value| (value ^ node.checked?) }
+end
+
+Capybara.add_selector(:select) do
+  label "select box"
+  xpath { |locator| XPath::HTML.select(locator) }
+  filter(:options) do |node, options|
+    actual = node.all(:xpath, './/option').map { |option| option.text }
+    options.sort == actual.sort
+  end
+  filter(:with_options) { |node, options| options.all? { |option| node.first(:option, option) } }
+  filter(:selected) do |node, selected|
+    actual = node.all(:xpath, './/option').select { |option| option.selected? }.map { |option| option.text }
+    [selected].flatten.sort == actual.sort
+  end
+end
+
+Capybara.add_selector(:option) do
+  xpath { |locator| XPath::HTML.option(locator) }
+end
+
+Capybara.add_selector(:file_field) do
+  label "file field"
+  xpath { |locator| XPath::HTML.file_field(locator) }
+end
+
+Capybara.add_selector(:content) do
+  xpath { |content| XPath::HTML.content(content) }
+end
+
+Capybara.add_selector(:table) do
+  xpath { |locator| XPath::HTML.table(locator) }
 end