nimboids-capybara 1.1.2

data/lib/capybara/node/simple.rb

@@ -0,0 +1,132 @@
+module Capybara
+  module Node
+
+    ##
+    #
+    # A {Capybara::Node::Simple} is a simpler version of {Capybara::Node::Base} which
+    # includes only {Capybara::Node::Finders} and {Capybara::Node::Matchers} and does
+    # not include {Capybara::Node::Actions}. This type of node is returned when
+    # using {Capybara.string}.
+    #
+    # It is useful in that it does not require a session, an application or a driver,
+    # but can still use Capybara's finders and matchers on any string that contains HTML.
+    #
+    class Simple
+      include Capybara::Node::Finders
+      include Capybara::Node::Matchers
+
+      attr_reader :native
+
+      def initialize(native)
+        native = Nokogiri::HTML(native) if native.is_a?(String)
+        @native = native
+      end
+
+      ##
+      #
+      # @return [String]    The text of the element
+      #
+      def text
+        native.text
+      end
+
+      ##
+      #
+      # Retrieve the given attribute
+      #
+      #     element[:title] # => HTML title attribute
+      #
+      # @param  [Symbol] attribute     The attribute to retrieve
+      # @return [String]               The value of the attribute
+      #
+      def [](name)
+        attr_name = name.to_s
+        if attr_name == 'value'
+          value
+        elsif 'input' == tag_name and 'checkbox' == native[:type] and 'checked' == attr_name
+          native['checked'] == 'checked'
+        else
+          native[attr_name]
+        end
+      end
+
+      ##
+      #
+      # @return [String]      The tag name of the element
+      #
+      def tag_name
+        native.node_name
+      end
+
+      ##
+      #
+      # An XPath expression describing where on the page the element can be found
+      #
+      # @return [String]      An XPath expression
+      #
+      def path
+        native.path
+      end
+
+      ##
+      #
+      # @return [String]    The value of the form element
+      #
+      def value
+        if tag_name == 'textarea'
+          native.content.sub(/\A\n/, '')
+        elsif tag_name == 'select'
+          if native['multiple'] == 'multiple'
+            native.xpath(".//option[@selected='selected']").map { |option| option[:value] || option.content  }
+          else
+            option = native.xpath(".//option[@selected='selected']").first || native.xpath(".//option").first
+            option[:value] || option.content if option
+          end
+        else
+          native[:value]
+        end
+      end
+
+      ##
+      #
+      # Whether or not the element is visible. Does not support CSS, so
+      # the result may be inaccurate.
+      #
+      # @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
+      end
+
+      ##
+      #
+      # Whether or not the element is checked.
+      #
+      # @return [Boolean]     Whether the element is checked
+      #
+      def checked?
+        native[:checked]
+      end
+
+      ##
+      #
+      # Whether or not the element is selected.
+      #
+      # @return [Boolean]     Whether the element is selected
+      #
+      def selected?
+        native[:selected]
+      end
+
+    protected
+
+      def find_in_base(selector, xpath)
+        native.xpath(xpath).map { |node| self.class.new(node) }
+      end
+
+      def wait_until
+        yield # simple nodes don't need to wait
+      end
+    end
+  end
+end

data/lib/capybara/rack_test/browser.rb

@@ -0,0 +1,121 @@
+class Capybara::RackTest::Browser
+  include ::Rack::Test::Methods
+
+  attr_reader :driver
+  attr_accessor :current_host
+
+  def initialize(driver)
+    @driver = driver
+  end
+
+  def app
+    driver.app
+  end
+
+  def options
+    driver.options
+  end
+
+  def visit(path, attributes = {})
+    reset_host!
+    process(:get, path, attributes)
+    follow_redirects!
+  end
+
+  def submit(method, path, attributes)
+    path = request_path if not path or path.empty?
+    process(method, path, attributes)
+    follow_redirects!
+  end
+
+  def follow(method, path, attributes = {})
+    return if path.gsub(/^#{request_path}/, '').start_with?('#')
+    process(method, path, attributes)
+    follow_redirects!
+  end
+
+  def follow_redirects!
+    5.times do
+      process(:get, last_response["Location"]) 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 = {})
+    new_uri = URI.parse(path)
+    current_uri = URI.parse(current_url)
+
+    if new_uri.host
+      @current_host = new_uri.scheme + '://' + new_uri.host
+    end
+
+    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
+
+    reset_cache!
+    send(method, path, attributes, env)
+  end
+
+  def current_url
+    last_request.url
+  rescue Rack::Test::Error
+    ""
+  end
+
+  def reset_host!
+    @current_host = (Capybara.app_host || Capybara.default_host)
+  end
+
+  def reset_cache!
+    @dom = nil
+  end
+
+  def body
+    dom.to_xml
+  end
+
+  def dom
+    @dom ||= Nokogiri::HTML(source)
+  end
+
+  def find(selector)
+    dom.xpath(selector).map { |node| Capybara::RackTest::Node.new(self, node) }
+  end
+
+  def source
+    last_response.body
+  rescue Rack::Test::Error
+    nil
+  end
+
+protected
+
+  def build_rack_mock_session
+    reset_host! unless current_host
+    Rack::MockSession.new(app, URI.parse(current_host).host)
+  end
+
+  def request_path
+    last_request.path
+  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

@@ -0,0 +1,80 @@
+require 'rack/test'
+require 'rack/utils'
+require 'mime/types'
+require 'nokogiri'
+require 'cgi'
+
+class Capybara::RackTest::Driver < Capybara::Driver::Base
+  DEFAULT_OPTIONS = {
+    :respect_data_method => true
+  }
+  attr_reader :app, :options
+
+  def initialize(app, options={})
+    raise ArgumentError, "rack-test requires a rack application, but none was given" unless app
+    @app = app
+    @options = DEFAULT_OPTIONS.merge(options)
+  end
+
+  def browser
+    @browser ||= Capybara::RackTest::Browser.new(self)
+  end
+
+  def response
+    browser.last_response
+  end
+
+  def request
+    browser.last_request
+  end
+
+  def visit(path, attributes = {})
+    browser.visit(path, attributes)
+  end
+
+  def submit(method, path, attributes)
+    browser.submit(method, path, attributes)
+  end
+
+  def follow(method, path, attributes = {})
+    browser.follow(method, path, attributes)
+  end
+
+  def current_url
+    browser.current_url
+  end
+
+  def response_headers
+    response.headers
+  end
+
+  def status_code
+    response.status
+  end
+
+  def find(selector)
+    browser.find(selector)
+  end
+
+  def body
+    browser.body
+  end
+
+  def source
+    browser.source
+  end
+
+  def dom
+    browser.dom
+  end
+
+  def reset!
+    @browser = nil
+  end
+
+  def get(*args, &block); browser.get(*args, &block); end
+  def post(*args, &block); browser.post(*args, &block); end
+  def put(*args, &block); browser.put(*args, &block); end
+  def delete(*args, &block); browser.delete(*args, &block); end
+  def header(key, value); browser.header(key, value); end
+end

data/lib/capybara/rack_test/form.rb

@@ -0,0 +1,80 @@
+class Capybara::RackTest::Form < Capybara::RackTest::Node
+  # This only needs to inherit from Rack::Test::UploadedFile because Rack::Test checks for
+  # the class specifically when determing whether to consturct the request as multipart.
+  # That check should be based solely on the form element's 'enctype' attribute value,
+  # which should probably be provided to Rack::Test in its non-GET request methods.
+  class NilUploadedFile < Rack::Test::UploadedFile
+    def initialize
+      @empty_file = Tempfile.new("nil_uploaded_file")
+      @empty_file.close
+    end
+
+    def original_filename; ""; end
+    def content_type; "application/octet-stream"; end
+    def path; @empty_file.path; end
+  end
+
+  def params(button)
+    params = {}
+
+    native.xpath("(.//input|.//select|.//textarea)[not(@disabled)]").map do |field|
+      case field.name
+      when 'input'
+        if %w(radio checkbox).include? field['type']
+          merge_param!(params, field['name'].to_s, field['value'].to_s) if field['checked']
+        elsif %w(submit image).include? field['type']
+          # TO DO identify the click button here (in document order, rather
+          # than leaving until the end of the params)
+        elsif field['type'] =='file'
+          if multipart?
+            file = \
+              if (value = field['value']).to_s.empty?
+                NilUploadedFile.new
+              else
+                content_type = MIME::Types.type_for(value).first.to_s
+                Rack::Test::UploadedFile.new(value, content_type)
+              end
+            merge_param!(params, field['name'].to_s, file)
+          else
+            merge_param!(params, field['name'].to_s, File.basename(field['value'].to_s))
+          end
+        else
+          merge_param!(params, field['name'].to_s, field['value'].to_s)
+        end
+      when 'select'
+        if field['multiple'] == 'multiple'
+          options = field.xpath(".//option[@selected]")
+          options.each do |option|
+            merge_param!(params, field['name'].to_s, (option['value'] || option.text).to_s)
+          end
+        else
+          option = field.xpath(".//option[@selected]").first
+          option ||= field.xpath('.//option').first
+          merge_param!(params, field['name'].to_s, (option['value'] || option.text).to_s) if option
+        end
+      when 'textarea'
+        merge_param!(params, field['name'].to_s, field.text.to_s)
+      end
+    end
+    merge_param!(params, button[:name], button[:value] || "") if button[:name]
+    params
+  end
+
+  def submit(button)
+    driver.submit(method, native['action'].to_s, params(button))
+  end
+
+  def multipart?
+    self[:enctype] == "multipart/form-data"
+  end
+
+private
+
+  def method
+    self[:method] =~ /post/i ? :post : :get
+  end
+
+  def merge_param!(params, key, value)
+    Rack::Utils.normalize_params(params, key, value)
+  end
+end

data/lib/capybara/rack_test/node.rb

@@ -0,0 +1,105 @@
+class Capybara::RackTest::Node < Capybara::Driver::Node
+  def text
+    native.text
+  end
+
+  def [](name)
+    string_node[name]
+  end
+
+  def value
+    string_node.value
+  end
+
+  def set(value)
+    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") }
+      native['checked'] = 'checked'
+    elsif tag_name == 'input' and type == 'checkbox'
+      if value && !native['checked']
+        native['checked'] = 'checked'
+      elsif !value && native['checked']
+        native.remove_attribute('checked')
+      end
+    elsif tag_name == 'input'
+      if (type == 'text' || type == 'password') && self[:maxlength] &&
+        !self[:maxlength].empty?
+        # Browser behavior for maxlength="0" is inconsistent, so we stick with
+        # Firefox, allowing no input
+        value = value[0...self[:maxlength].to_i]
+      end
+      native['value'] = value.to_s
+    elsif tag_name == "textarea"
+      native.content = value.to_s
+    end
+  end
+
+  def select_option
+    if select_node['multiple'] != 'multiple'
+      select_node.find(".//option[@selected]").each { |node| node.native.remove_attribute("selected") }
+    end
+    native["selected"] = 'selected'
+  end
+
+  def unselect_option
+    if select_node['multiple'] != 'multiple'
+      raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
+    end
+    native.remove_attribute('selected')
+  end
+
+  def click
+    if tag_name == 'a'
+      method = self["data-method"] if driver.options[:respect_data_method]
+      method ||= :get
+      driver.follow(method, self[:href].to_s)
+    elsif (tag_name == 'input' and %w(submit image).include?(type)) or
+        ((tag_name == 'button') and type.nil? or type == "submit")
+      Capybara::RackTest::Form.new(driver, form).submit(self)
+    end
+  end
+
+  def tag_name
+    native.node_name
+  end
+
+  def visible?
+    string_node.visible?
+  end
+
+  def checked?
+    string_node.checked?
+  end
+
+  def selected?
+    string_node.selected?
+  end
+
+  def path
+    native.path
+  end
+
+  def find(locator)
+    native.xpath(locator).map { |n| self.class.new(driver, n) }
+  end
+
+private
+
+  def string_node
+    @string_node ||= Capybara::Node::Simple.new(native)
+  end
+
+  # a reference to the select node if this is an option node
+  def select_node
+    find('./ancestor::select').first
+  end
+
+  def type
+    native[:type]
+  end
+
+  def form
+    native.ancestors('form').first
+  end
+end