auxesis-webrat 0.4.1

data/install.rb

@@ -0,0 +1 @@
+puts IO.read(File.join(File.dirname(__FILE__), 'README.rdoc'))

data/lib/webrat.rb

@@ -0,0 +1,34 @@
+require "rubygems"
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Webrat
+  # The common base class for all exceptions raised by Webrat.
+  class WebratError < StandardError
+  end
+
+  VERSION = '0.4.1'
+
+  def self.require_xml
+    gem "nokogiri", ">= 1.0.6"
+    
+    if on_java?
+      # We need Nokogiri's CSS to XPath support, even if using REXML and Hpricot for parsing and searching
+      require "nokogiri/css"
+      require "hpricot"
+      require "rexml/document"
+    else
+      require "nokogiri"
+      require "webrat/core/xml/nokogiri"
+    end
+  end
+  
+  def self.on_java?
+    RUBY_PLATFORM =~ /java/
+  end
+  
+end
+
+Webrat.require_xml
+
+require "webrat/core"

data/lib/webrat/core.rb

@@ -0,0 +1,14 @@
+require "webrat/core/configuration"
+require "webrat/core/xml"
+require "webrat/core/xml/nokogiri"
+require "webrat/core/logging"
+require "webrat/core/elements/form"
+require "webrat/core/scope"
+require "webrat/core/elements/link"
+require "webrat/core/elements/area"
+require "webrat/core/elements/label"
+require "webrat/core/elements/select_option"
+require "webrat/core/session"
+require "webrat/core/methods"
+require "webrat/core/matchers"
+require "webrat/core/save_and_open_page"

data/lib/webrat/core/configuration.rb

@@ -0,0 +1,89 @@
+require "webrat/core_extensions/deprecate"
+
+module Webrat
+
+  # Configures Webrat. If this is not done, Webrat will be created
+  # with all of the default settings.
+  def self.configure(configuration = Webrat.configuration)
+    yield configuration if block_given?
+    @@configuration = configuration
+  end
+
+  def self.configuration # :nodoc:
+    @@configuration ||= Webrat::Configuration.new
+  end
+
+  # Webrat can be configured using the Webrat.configure method. For example:
+  #
+  #   Webrat.configure do |config|
+  #     config.parse_with_nokogiri = false
+  #   end
+  class Configuration
+
+    # Should XHTML be parsed with Nokogiri? Defaults to true, except on JRuby. When false, Hpricot and REXML are used
+    attr_writer :parse_with_nokogiri
+
+    # Webrat's mode, set automatically when requiring webrat/rails, webrat/merb, etc.
+    attr_reader :mode # :nodoc:
+
+    # Save and open pages with error status codes (500-599) in a browser? Defualts to true.
+    attr_writer :open_error_files
+
+    # Which rails environment should the selenium tests be run in? Defaults to selenium.
+    attr_accessor :application_environment
+    webrat_deprecate :selenium_environment, :application_environment
+    webrat_deprecate :selenium_environment=, :application_environment=
+
+    # Which port is the application running on for selenium testing? Defaults to 3001.
+    attr_accessor :application_port
+    webrat_deprecate :selenium_port, :application_port
+    webrat_deprecate :selenium_port=, :application_port=
+
+    # Which server the application is running on for selenium testing? Defaults to localhost
+    attr_accessor :application_address
+
+    # Which server Selenium server is running on. Defaults to nil(server starts in webrat process and runs locally)
+    attr_accessor :selenium_server_address
+
+    # Which server Selenium port is running on. Defaults to 4444
+    attr_accessor :selenium_server_port
+
+    # Set the key that Selenium uses to determine the browser running. Default *firefox
+    attr_accessor :selenium_browser_key
+
+    def initialize # :nodoc:
+      self.open_error_files = true
+      self.parse_with_nokogiri = !Webrat.on_java?
+      self.application_environment = :selenium
+      self.application_port = 3001
+      self.application_address = 'localhost'
+      self.selenium_server_port = 4444
+      self.selenium_browser_key = '*firefox'
+    end
+
+    def parse_with_nokogiri? #:nodoc:
+      @parse_with_nokogiri ? true : false
+    end
+
+    def open_error_files? #:nodoc:
+      @open_error_files ? true : false
+    end
+
+    # Allows setting of webrat's mode, valid modes are:
+    # :rails, :selenium, :rack, :sinatra, :mechanize, :merb
+    def mode=(mode)
+      @mode = mode.to_sym
+      
+      # This is a temporary hack to support backwards compatibility
+      # with Merb 1.0.8 until it's updated to use the new Webrat.configure
+      # syntax
+      if @mode == :merb
+        require("webrat/merb_session")
+      else
+        require("webrat/#{mode}")
+      end
+    end
+
+  end
+
+end

data/lib/webrat/core/elements/area.rb

@@ -0,0 +1,31 @@
+require "webrat/core/elements/element"
+
+module Webrat
+  class Area < Element #:nodoc:
+    
+    def self.xpath_search
+      ".//area"
+    end
+    
+    def click(method = nil, options = {})
+      @session.request_page(absolute_href, :get, {})
+    end
+    
+  protected
+    
+    def href
+      Webrat::XML.attribute(@element, "href")
+    end
+   
+    def absolute_href
+      if href =~ /^\?/
+        "#{@session.current_url}#{href}"
+      elsif href !~ %r{^https?://[\w|.]+(/.*)} && (href !~ /^\//)
+        "#{@session.current_url}/#{href}"
+      else
+        href
+      end
+    end
+    
+  end
+end

data/lib/webrat/core/elements/element.rb

@@ -0,0 +1,33 @@
+module Webrat
+  
+  class Element # :nodoc:
+    
+    def self.load_all(session, dom)
+      Webrat::XML.xpath_search(dom, xpath_search).map do |element| 
+        load(session, element)
+      end
+    end
+    
+    def self.load(session, element)
+      return nil if element.nil?
+      session.elements[Webrat::XML.xpath_to(element)] ||= self.new(session, element)
+    end
+    
+    attr_reader :element
+    
+    def initialize(session, element)
+      @session  = session
+      @element  = element
+    end
+    
+    def path
+      Webrat::XML.xpath_to(@element)
+    end
+    
+    def inspect
+      "#<#{self.class} @element=#{element.inspect}>"
+    end
+    
+  end
+  
+end

data/lib/webrat/core/elements/field.rb

@@ -0,0 +1,404 @@
+require "cgi"
+require "webrat/core_extensions/blank"
+require "webrat/core_extensions/nil_to_param"
+
+require "webrat/core/elements/element"
+
+module Webrat
+  # Raised when Webrat is asked to manipulate a disabled form field
+  class DisabledFieldError < WebratError
+  end
+  
+  class Field < Element #:nodoc:
+    attr_reader :value
+    
+    def self.xpath_search
+      [".//button", ".//input", ".//textarea", ".//select"]
+    end
+    
+    def self.field_classes
+      @field_classes || []
+    end
+    
+    def self.inherited(klass)
+      @field_classes ||= []
+      @field_classes << klass
+      # raise args.inspect
+    end
+    
+    def self.load(session, element)
+      return nil if element.nil?
+      session.elements[Webrat::XML.xpath_to(element)] ||= field_class(element).new(session, element)
+    end
+    
+    def self.field_class(element)
+      case element.name
+      when "button"   then ButtonField
+      when "select"   then SelectField
+      when "textarea" then TextareaField
+      else
+        case Webrat::XML.attribute(element, "type")
+        when "checkbox" then CheckboxField
+        when "hidden"   then HiddenField
+        when "radio"    then RadioField
+        when "password" then PasswordField
+        when "file"     then FileField
+        when "reset"    then ResetField
+        when "submit"   then ButtonField
+        when "button"   then ButtonField
+        when "image"    then ButtonField
+        else  TextField
+        end
+      end
+    end
+    
+    def initialize(*args)
+      super
+      @value = default_value
+    end
+
+    def label_text
+      return nil if labels.empty?
+      labels.first.text
+    end
+    
+    def id
+      Webrat::XML.attribute(@element, "id")
+    end
+
+    def disabled?
+      @element.attributes.has_key?("disabled") && Webrat::XML.attribute(@element, "disabled") != 'false'
+    end
+    
+    def raise_error_if_disabled
+      return unless disabled?
+      raise DisabledFieldError.new("Cannot interact with disabled form element (#{self})")
+    end
+        
+    def to_param
+      return nil if disabled?
+      
+      case Webrat.configuration.mode
+      when :rails
+        rails_request_parser.parse_query_parameters("#{name}=#{escaped_value}")
+      when :merb
+        ::Merb::Parse.query("#{name}=#{escaped_value}")
+      else
+        { name => escaped_value }
+      end
+    end
+
+    def to_multipart_param
+      { name => escaped_value }
+    end
+    
+    def set(value)
+      @value = value
+    end
+    
+    def unset
+      @value = default_value
+    end
+    
+    def name
+      Webrat::XML.attribute(@element, "name")
+    end
+    
+  protected
+  
+    def rails_request_parser
+      if defined?(ActionController::AbstractRequest)
+        ActionController::AbstractRequest
+      else
+        # For Rails > 2.2
+        ActionController::UrlEncodedPairParser
+      end
+    end
+  
+    def form
+      Form.load(@session, form_element)
+    end
+    
+    def form_element
+      parent = @element.parent
+      
+      while parent.respond_to?(:parent)
+        return parent if parent.name == 'form'
+        parent = parent.parent
+      end
+    end
+    
+    def escaped_value
+      CGI.escape(@value.to_s)
+    end
+    
+    def labels
+      @labels ||= label_elements.map do |element|
+        Label.load(@session, element)
+      end
+    end
+    
+    def label_elements
+      return @label_elements unless @label_elements.nil?
+      @label_elements = []
+    
+      parent = @element.parent
+      while parent.respond_to?(:parent)
+        if parent.name == 'label'
+          @label_elements.push parent
+          break
+        end
+        parent = parent.parent
+      end
+    
+      unless id.blank?
+        @label_elements += Webrat::XML.xpath_search(form.element, ".//label[@for = '#{id}']")
+      end
+    
+      @label_elements
+    end
+    
+    def default_value
+      Webrat::XML.attribute(@element, "value")
+    end
+    
+    def replace_param_value(params, oval, nval)
+      output = Hash.new
+      params.each do |key, value|
+        case value
+        when Hash
+          value = replace_param_value(value, oval, nval)
+        when Array
+          value = value.map { |o| o == oval ? nval : oval }
+        when oval
+          value = nval
+        end
+        output[key] = value
+      end
+      output
+    end
+  end
+  
+  class ButtonField < Field #:nodoc:
+
+    def self.xpath_search
+      [".//button", ".//input[@type = 'submit']", ".//input[@type = 'button']", ".//input[@type = 'image']"]
+    end
+    
+    def to_param
+      return nil if @value.nil?
+      super
+    end
+
+    def default_value
+      nil
+    end
+
+    def click
+      raise_error_if_disabled
+      set(Webrat::XML.attribute(@element, "value")) unless Webrat::XML.attribute(@element, "name").blank?
+      form.submit
+    end
+
+  end
+
+  class HiddenField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//input[@type = 'hidden']"
+    end
+    
+    def to_param
+      if collection_name?
+        super
+      else
+        checkbox_with_same_name = form.field_named(name, CheckboxField)
+
+        if checkbox_with_same_name.to_param.blank?
+          super
+        else
+          nil
+        end
+      end
+    end
+
+  protected
+
+    def collection_name?
+      name =~ /\[\]/
+    end
+
+  end
+
+  class CheckboxField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//input[@type = 'checkbox']"
+    end
+    
+    def to_param
+      return nil if @value.nil?
+      super
+    end
+
+    def check
+      raise_error_if_disabled
+      set(Webrat::XML.attribute(@element, "value") || "on")
+    end
+    
+    def checked?
+      Webrat::XML.attribute(@element, "checked") == "checked"
+    end
+
+    def uncheck
+      raise_error_if_disabled
+      set(nil)
+    end
+
+  protected
+
+    def default_value
+      if Webrat::XML.attribute(@element, "checked") == "checked"
+        Webrat::XML.attribute(@element, "value") || "on"
+      else
+        nil
+      end
+    end
+
+  end
+
+  class PasswordField < Field #:nodoc:
+    
+    def self.xpath_search
+      ".//input[@type = 'password']"
+    end
+    
+  end
+
+  class RadioField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//input[@type = 'radio']"
+    end
+    
+    def to_param
+      return nil if @value.nil?
+      super
+    end
+    
+    def choose
+      raise_error_if_disabled
+      other_options.each do |option|
+        option.set(nil)
+      end
+      
+      set(Webrat::XML.attribute(@element, "value") || "on")
+    end
+    
+    def checked?
+      Webrat::XML.attribute(@element, "checked") == "checked"
+    end
+    
+  protected
+
+    def other_options
+      form.fields.select { |f| f.name == name }
+    end
+    
+    def default_value
+      if Webrat::XML.attribute(@element, "checked") == "checked"
+        Webrat::XML.attribute(@element, "value") || "on"
+      else
+        nil
+      end
+    end
+
+  end
+
+  class TextareaField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//textarea"
+    end
+    
+  protected
+
+    def default_value
+      Webrat::XML.inner_html(@element)
+    end
+
+  end
+  
+  class FileField < Field #:nodoc:
+    
+    def self.xpath_search
+      ".//input[@type = 'file']"
+    end
+    
+    attr_accessor :content_type
+
+    def set(value, content_type = nil)
+      super(value)
+      @content_type = content_type
+    end
+
+    def to_param
+      if @value.nil?
+        super
+      else
+        if Webrat.configuration.mode == :merb
+          nil
+        else
+          replace_param_value(super, @value, test_uploaded_file)
+        end
+      end
+    end
+    
+  protected
+  
+    def test_uploaded_file
+      if content_type
+        ActionController::TestUploadedFile.new(@value, content_type)
+      else
+        ActionController::TestUploadedFile.new(@value)
+      end
+    end
+
+  end
+
+  class TextField < Field #:nodoc:
+    def self.xpath_search
+      [".//input[@type = 'text']", ".//input[not(@type)]"]
+    end
+  end
+
+  class ResetField < Field #:nodoc:
+    def self.xpath_search
+      ".//input[@type = 'reset']"
+    end
+  end
+
+  class SelectField < Field #:nodoc:
+
+    def self.xpath_search
+      ".//select"
+    end
+
+    def options
+      @options ||= SelectOption.load_all(@session, @element)
+    end
+    
+  protected
+
+    def default_value
+      selected_options = Webrat::XML.xpath_search(@element, ".//option[@selected = 'selected']")
+      selected_options = Webrat::XML.xpath_search(@element, ".//option[position() = 1]") if selected_options.empty? 
+      
+      selected_options.map do |option|
+        return "" if option.nil?
+        Webrat::XML.attribute(option, "value") || Webrat::XML.inner_html(option)
+      end
+    end
+
+  end
+end