capybara 2.0.3 → 2.1.0.beta1

data/lib/capybara/rails.rb

@@ -3,7 +3,7 @@ require 'capybara/dsl'
 
 Capybara.app = Rack::Builder.new do
   map "/" do
-    if Gem::Version.new(Rails.version) >= Gem::Version.new("3.0")
+    if Rails.version.to_f >= 3.0
       run Rails.application
     else # Rails 2
       use Rails::Rack::Static
@@ -12,7 +12,6 @@ Capybara.app = Rack::Builder.new do
   end
 end.to_app
 
-Capybara.asset_root = Rails.root.join('public')
 Capybara.save_and_open_page_path = Rails.root.join('tmp/capybara')
 
 # Override default rack_test driver to respect data-method attributes.

data/lib/capybara/result.rb

@@ -1,6 +1,23 @@
 require 'forwardable'
 
 module Capybara
+
+  ##
+  # A {Capybara::Result} represents a collection of {Capybara::Element} on the page. It is possible to interact with this
+  # collection similar to an Array because it implements Enumerable and offers the following Array methods through delegation:
+  #
+  # * []
+  # * each()
+  # * at()
+  # * size()
+  # * count()
+  # * length()
+  # * first()
+  # * last()
+  # * empty?()
+  #
+  # @see Capybara::Element
+  #
   class Result
     include Enumerable
     extend Forwardable
@@ -15,36 +32,13 @@ module Capybara
     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
+      Capybara::Helpers.matches_count?(@result.size, @query.options)
     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
+      message = Capybara::Helpers.failure_message(@query.description, @query.options)
       if count > 0
-        message << ", found #{count} #{declension("match", "matches")}: " << @result.map(&:text).map(&:inspect).join(", ")
+        message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << @result.map(&:text).map(&:inspect).join(", ")
       else
         message << " but there were no matches"
       end
@@ -56,17 +50,7 @@ module Capybara
     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
+      failure_message.sub(/(to be found|to find)/, 'not \1')
     end
   end
 end

data/lib/capybara/rspec/matchers.rb

@@ -1,6 +1,16 @@
 module Capybara
   module RSpecMatchers
-    class HaveSelector
+    class Matcher
+      def wrap(actual)
+        if actual.respond_to?("has_selector?")
+          actual
+        else
+          Capybara.string(actual.to_s)
+        end
+      end
+    end
+
+    class HaveSelector < Matcher
       def initialize(*args)
         @args = args
       end
@@ -17,59 +27,77 @@ module Capybara
         "have #{query.description}"
       end
 
-      def wrap(actual)
-        if actual.respond_to?("has_selector?")
-          actual
-        else
-          Capybara.string(actual.to_s)
-        end
-      end
-
       def query
         @query ||= Capybara::Query.new(*@args)
       end
     end
 
-    class HaveText
-      attr_reader :text
+    class HaveText < Matcher
+      attr_reader :type, :content, :options
 
-      def initialize(text)
-        @text = text
+      def initialize(*args)
+        @type = args.shift if args.first.is_a?(Symbol)
+        @content = args.shift
+        @options = (args.first.is_a?(Hash))? args.first : {}
       end
 
       def matches?(actual)
         @actual = wrap(actual)
-        @actual.has_text?(text)
+        @actual.has_text?(type, content, options)
       end
 
       def does_not_match?(actual)
         @actual = wrap(actual)
-        @actual.has_no_text?(text)
+        @actual.has_no_text?(type, content, options)
       end
 
       def failure_message_for_should
-        "expected there to be text #{format(text)} in #{format(@actual.text)}"
+        message = Capybara::Helpers.failure_message(description, options)
+        message << " in #{format(@actual.text(type))}"
+        message
       end
 
       def failure_message_for_should_not
-        "expected there not to be text #{format(text)} in #{format(@actual.text)}"
+        failure_message_for_should.sub(/(to find)/, 'not \1')
       end
 
       def description
-        "have text #{format(text)}"
+        "text #{format(content)}"
       end
 
-      def wrap(actual)
-        if actual.respond_to?("has_selector?")
-          actual
-        else
-          Capybara.string(actual.to_s)
-        end
+      def format(content)
+        content = Capybara::Helpers.normalize_whitespace(content) unless content.is_a? Regexp
+        content.inspect
+      end
+    end
+
+    class HaveTitle < Matcher
+      attr_reader :title
+
+      def initialize(title)
+        @title = title
       end
 
-      def format(text)
-        text = Capybara::Helpers.normalize_whitespace(text) unless text.is_a? Regexp
-        text.inspect
+      def matches?(actual)
+        @actual = wrap(actual)
+        @actual.has_title?(title)
+      end
+
+      def does_not_match?(actual)
+        @actual = wrap(actual)
+        @actual.has_no_title?(title)
+      end
+
+      def failure_message_for_should
+        "expected there to be title #{title.inspect} in #{@actual.title.inspect}"
+      end
+
+      def failure_message_for_should_not
+        "expected there not to be title #{title.inspect} in #{@actual.title.inspect}"
+      end
+
+      def description
+        "have title #{title.inspect}"
       end
     end
 
@@ -85,12 +113,13 @@ module Capybara
       HaveSelector.new(:css, css, options)
     end
 
-    def have_content(text)
-      HaveText.new(text)
+    def have_text(*args)
+      HaveText.new(*args)
     end
+    alias_method :have_content, :have_text
 
-    def have_text(text)
-      HaveText.new(text)
+    def have_title(title)
+      HaveTitle.new(title)
     end
 
     def have_link(locator, options={})

data/lib/capybara/selector.rb

@@ -1,7 +1,26 @@
 module Capybara
   class Selector
-    attr_reader :name, :custom_filters
+    class Filter
+      def initialize(name, block, options={})
+        @name = name
+        @block = block
+        @options = options
+      end
+
+      def default?
+        @options.has_key?(:default)
+      end
+
+      def default
+        @options[:default]
+      end
+
+      def matches?(node, value)
+        @block.call(node, value)
+      end
+    end
 
+    attr_reader :name, :custom_filters, :format
 
     class << self
       def all
@@ -27,16 +46,16 @@ module Capybara
     end
 
     def xpath(&block)
+      @format = :xpath
       @xpath = block if block
       @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
+      @format = :css
+      @css = block if block
+      @css
     end
 
     def match(&block)
@@ -50,15 +69,19 @@ module Capybara
     end
 
     def call(locator)
-      @xpath.call(locator)
+      if @format==:css
+        @css.call(locator)
+      else
+        @xpath.call(locator)
+      end
     end
 
     def match?(locator)
       @match and @match.call(locator)
     end
 
-    def filter(name, &block)
-      @custom_filters[name] = block
+    def filter(name, options={}, &block)
+      @custom_filters[name] = Filter.new(name, block, options)
     end
   end
 end
@@ -79,8 +102,15 @@ 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(:disabled, :default => false) { |node, value| not(value ^ node.disabled?) }
   filter(:with) { |node, with| node.value == with }
-  filter(:type) { |node, type| node[:type] == type }
+  filter(:type) do |node, type|
+    if ['textarea', 'select'].include?(type)
+      node.tag_name == type
+    else
+      node[:type] == type
+    end
+  end
 end
 
 Capybara.add_selector(:fieldset) do
@@ -90,6 +120,7 @@ end
 Capybara.add_selector(:link_or_button) do
   label "link or button"
   xpath { |locator| XPath::HTML.link_or_button(locator) }
+  filter(:disabled, :default => false) { |node, value| node.tag_name == "a" or not(value ^ node.disabled?) }
 end
 
 Capybara.add_selector(:link) do
@@ -101,11 +132,13 @@ end
 
 Capybara.add_selector(:button) do
   xpath { |locator| XPath::HTML.button(locator) }
+  filter(:disabled, :default => false) { |node, value| not(value ^ node.disabled?) }
 end
 
 Capybara.add_selector(:fillable_field) do
   label "field"
   xpath { |locator| XPath::HTML.fillable_field(locator) }
+  filter(:disabled, :default => false) { |node, value| not(value ^ node.disabled?) }
 end
 
 Capybara.add_selector(:radio_button) do
@@ -113,12 +146,14 @@ Capybara.add_selector(:radio_button) do
   xpath { |locator| XPath::HTML.radio_button(locator) }
   filter(:checked) { |node, value| not(value ^ node.checked?) }
   filter(:unchecked) { |node, value| (value ^ node.checked?) }
+  filter(:disabled, :default => false) { |node, value| not(value ^ node.disabled?) }
 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?) }
+  filter(:disabled, :default => false) { |node, value| not(value ^ node.disabled?) }
 end
 
 Capybara.add_selector(:select) do
@@ -133,6 +168,7 @@ Capybara.add_selector(:select) do
     actual = node.all(:xpath, './/option').select { |option| option.selected? }.map { |option| option.text }
     [selected].flatten.sort == actual.sort
   end
+  filter(:disabled, :default => false) { |node, value| not(value ^ node.disabled?) }
 end
 
 Capybara.add_selector(:option) do
@@ -142,10 +178,7 @@ 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) }
+  filter(:disabled, :default => false) { |node, value| not(value ^ node.disabled?) }
 end
 
 Capybara.add_selector(:table) do

data/lib/capybara/selenium/driver.rb

@@ -1,4 +1,13 @@
-require 'selenium-webdriver'
+begin
+  require 'selenium-webdriver'
+rescue LoadError => e
+  if e.message =~ /selenium-webdriver/
+    raise LoadError, "Capybara's selenium driver is unable to load `selenium-webdriver`, please install the gem and add `gem 'selenium-webdriver'` to your Gemfile if you are using bundler."
+  else
+    raise e
+  end
+end
+
 
 class Capybara::Selenium::Driver < Capybara::Driver::Base
   DEFAULT_OPTIONS = {
@@ -27,6 +36,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     @app = app
     @browser = nil
     @exit_status = nil
+    @frame_handles = {}
     @options = DEFAULT_OPTIONS.merge(options)
   end
 
@@ -38,14 +48,22 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     browser.page_source
   end
 
+  def title
+    browser.title
+  end
+
   def current_url
     browser.current_url
   end
 
-  def find(selector)
+  def find_xpath(selector)
     browser.find_elements(:xpath, selector).map { |node| Capybara::Selenium::Node.new(self, node) }
   end
 
+  def find_css(selector)
+    browser.find_elements(:css, selector).map { |node| Capybara::Selenium::Node.new(self, node) }
+  end
+
   def wait?; true; end
   def needs_server?; true; end
 
@@ -74,12 +92,29 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     end
   end
 
-  def within_frame(frame_id)
-    old_window = browser.window_handle
-    browser.switch_to.frame(frame_id)
+  ##
+  #
+  # Webdriver supports frame name, id, index(zero-based) or {Capybara::Element} to find iframe
+  #
+  # @overload within_frame(index)
+  #   @param [Integer] index                 index of a frame
+  # @overload within_frame(name_or_id)
+  #   @param [String] name_or_id             name or id of a frame
+  # @overload within_frame(element)
+  #   @param [Capybara::Node::Base] a_node   frame element
+  #
+  def within_frame(frame_handle)
+    @frame_handles[browser.window_handle] ||= []
+    frame_handle = frame_handle.native if frame_handle.is_a?(Capybara::Node::Base)
+    @frame_handles[browser.window_handle] << frame_handle
+    a=browser.switch_to.frame(frame_handle)
     yield
   ensure
-    browser.switch_to.window old_window
+    # There doesnt appear to be any way in Webdriver to move back to a parent frame
+    # other than going back to the root and then reiterating down
+    @frame_handles[browser.window_handle].pop
+    browser.switch_to.default_content
+    @frame_handles[browser.window_handle].each { |fh| browser.switch_to.frame(fh) }
   end
 
   def find_window( selector )
@@ -111,4 +146,5 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   def invalid_element_errors
     [Selenium::WebDriver::Error::StaleElementReferenceError, Selenium::WebDriver::Error::UnhandledError, Selenium::WebDriver::Error::ElementNotVisibleError]
   end
+
 end