indirect-webrat 0.7.4

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

@@ -0,0 +1,127 @@
+require "webrat/core/elements/field"
+require "webrat/core_extensions/blank"
+
+require "webrat/core/elements/element"
+require "webrat/core/locators/field_named_locator"
+
+module Webrat
+  class Form < Element #:nodoc:
+    attr_reader :element
+
+    def self.xpath_search
+      [".//form"]
+    end
+
+    def fields
+      @fields ||= Field.load_all(@session, @element)
+    end
+
+    def submit
+      @session.request_page(form_action, form_method, params)
+    end
+
+    def field_named(name, *field_types)
+      Webrat::Locators::FieldNamedLocator.new(@session, dom, name, *field_types).locate
+    end
+
+  protected
+
+    def dom
+      @session.dom.xpath(path).first
+    end
+
+    def fields_by_type(field_types)
+      if field_types.any?
+        fields.select { |f| field_types.include?(f.class) }
+      else
+        fields
+      end
+    end
+
+    # iterate over all form fields to build a request querystring to get params from it,
+    # for file_field we made a work around to pass a digest as value to later replace it
+    # in params hash with the real file.
+    def params
+      query_string = []
+      replaces = {}
+
+      fields.each do |field|
+        next if field.to_query_string.nil?
+        replaces.merge!({field.digest_value => field.test_uploaded_file}) if field.is_a?(FileField)
+        query_string << field.to_query_string
+      end
+
+      query_params = self.class.query_string_to_params(query_string.join('&'))
+
+      query_params = self.class.replace_params_values(query_params, replaces)
+
+      self.class.unescape_params(query_params)
+    end
+
+    def form_method
+      @element["method"].blank? ? :get : @element["method"].downcase
+    end
+
+    def form_action
+      @element["action"].blank? ? @session.current_url : @element["action"]
+    end
+
+    def self.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 : ( o.is_a?(Hash) ? replace_param_value(o, oval, nval) : o) }
+        when oval
+          value = nval
+        end
+        output[key] = value
+      end
+      output
+    end
+
+    def self.replace_params_values(params, values)
+      values.each do |key, value|
+        params = replace_param_value(params, key, value)
+      end
+      params
+    end
+
+    def self.unescape_params(params)
+      case params.class.name
+      when 'Hash', 'Mash'
+        params.each { |key,value| params[key] = unescape_params(value) }
+        params
+      when 'Array'
+        params.collect { |value| unescape_params(value) }
+      else
+        params.is_a?(String) ? CGI.unescapeHTML(params) : params
+      end
+    end
+
+    def self.query_string_to_params(query_string)
+      case Webrat.configuration.mode
+      when :rails
+        parse_rails_request_params(query_string)
+      when :merb
+        ::Merb::Parse.query(query_string)
+      when :rack, :sinatra
+        Rack::Utils.parse_nested_query(query_string)
+      else
+        query_string.split('&').map {|query| { query.split('=').first => query.split('=').last }}
+      end
+    end
+
+    def self.parse_rails_request_params(query_string)
+      if defined?(ActionController::AbstractRequest)
+        ActionController::AbstractRequest.parse_query_parameters(query_string)
+      elsif defined?(ActionController::UrlEncodedPairParser)
+        ActionController::UrlEncodedPairParser.parse_query_parameters(query_string)
+      else
+        Rack::Utils.parse_nested_query(query_string)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require "webrat/core/elements/element"
+
+module Webrat
+  class Label < Element #:nodoc:
+
+    attr_reader :element
+
+    def self.xpath_search
+      [".//label"]
+    end
+
+    def for_id
+      @element["for"]
+    end
+
+    def field
+      Field.load(@session, field_element)
+    end
+
+  protected
+
+    def field_element
+      if for_id.blank?
+        @element.xpath(*Field.xpath_search_excluding_hidden).first
+      else
+        @session.current_dom.css("#" + for_id).first
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,93 @@
+require "English"
+
+require "webrat/core_extensions/blank"
+require "webrat/core/elements/element"
+
+module Webrat
+  class Link < Element #:nodoc:
+
+    def self.xpath_search
+      [".//a[@href]"]
+    end
+
+    def click(options = {})
+      method = options[:method] || http_method
+      return if href =~ /^#/ && method == :get
+
+      options[:javascript] = true if options[:javascript].nil?
+
+      if options[:javascript]
+        @session.request_page(absolute_href, method, data)
+      else
+        @session.request_page(absolute_href, :get, {})
+      end
+    end
+
+  protected
+
+    def id
+      @element["id"]
+    end
+
+    def data
+      authenticity_token.blank? ? {} : {"authenticity_token" => authenticity_token}
+    end
+
+    def title
+      @element["title"]
+    end
+
+    def href
+      @element["href"]
+    end
+
+    def absolute_href
+      if href =~ /^\?/
+        "#{@session.current_url}#{href}"
+      elsif href !~ %r{^https?://} && (href !~ /^\//)
+        "#{@session.current_url}/#{href}"
+      else
+        href
+      end
+    end
+
+    def authenticity_token
+      return unless onclick && onclick.include?("s.setAttribute('name', 'authenticity_token');") &&
+        ( onclick =~ /s\.setAttribute\('value', '([a-f0-9]{40})'\);/ || onclick =~ /s\.setAttribute\('value', '(.{44})'\);/ )
+      $LAST_MATCH_INFO.captures.first
+    end
+
+    def onclick
+      @element["onclick"]
+    end
+
+    def http_method
+      if !onclick.blank? && onclick.include?("f.submit()")
+        http_method_from_js_form
+      else
+        :get
+      end
+    end
+
+    def http_method_from_js_form
+      if onclick.include?("m.setAttribute('name', '_method')")
+        http_method_from_fake_method_param
+      else
+        :post
+      end
+    end
+
+    def http_method_from_fake_method_param
+      if onclick.include?("m.setAttribute('value', 'delete')")
+        :delete
+      elsif onclick.include?("m.setAttribute('value', 'put')")
+        :put
+      elsif onclick.include?("m.setAttribute('value', 'post')")
+        :post
+      else
+        raise Webrat::WebratError.new("No HTTP method for _method param in #{onclick.inspect}")
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,48 @@
+require "webrat/core/elements/element"
+
+module Webrat
+  class SelectOption < Element #:nodoc:
+
+    def self.xpath_search
+      [".//option"]
+    end
+
+    def choose
+      select.raise_error_if_disabled
+      select.set(value)
+    end
+
+    def unchoose
+      select.raise_error_if_disabled
+      select.unset(value)
+    end
+
+    def inner_text
+      @element.inner_text
+    end
+
+  protected
+
+    def select
+      SelectField.load(@session, select_element)
+    end
+
+    def select_element
+      parent = @element.parent
+
+      while parent.respond_to?(:parent)
+        return parent if parent.name == 'select'
+        parent = parent.parent
+      end
+    end
+
+    def value
+      @element["value"] || @element.inner_html
+    end
+
+    def label
+      @element.inner_html
+    end
+
+  end
+end

data/lib/webrat/core/locators.rb

@@ -0,0 +1,20 @@
+require "webrat/core/locators/area_locator"
+require "webrat/core/locators/button_locator"
+require "webrat/core/locators/field_labeled_locator"
+require "webrat/core/locators/label_locator"
+require "webrat/core/locators/field_named_locator"
+require "webrat/core/locators/field_by_id_locator"
+require "webrat/core/locators/select_option_locator"
+require "webrat/core/locators/link_locator"
+require "webrat/core/locators/field_locator"
+require "webrat/core/locators/form_locator"
+
+module Webrat
+  module Locators
+
+    def field_by_xpath(xpath)
+      Field.load(@session, dom.xpath(xpath).first)
+    end
+
+  end
+end

data/lib/webrat/core/locators/area_locator.rb

@@ -0,0 +1,38 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+
+    class AreaLocator < Locator # :nodoc:
+
+      def locate
+        Area.load(@session, area_element)
+      end
+
+      def area_element
+        area_elements.detect do |area_element|
+          area_element["title"] =~ matcher ||
+          area_element["id"] =~ matcher
+        end
+      end
+
+      def matcher
+        /#{Regexp.escape(@value.to_s)}/i
+      end
+
+      def area_elements
+        @dom.xpath(*Area.xpath_search)
+      end
+
+      def error_message
+        "Could not find area with name #{@value}"
+      end
+
+    end
+
+    def find_area(id_or_title) #:nodoc:
+      AreaLocator.new(@session, dom, id_or_title).locate!
+    end
+
+  end
+end

data/lib/webrat/core/locators/button_locator.rb

@@ -0,0 +1,54 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+
+    class ButtonLocator < Locator # :nodoc:
+
+      def locate
+        ButtonField.load(@session, button_element)
+      end
+
+      def button_element
+        button_elements.detect do |element|
+          @value.nil?             ||
+          matches_id?(element)    ||
+          matches_value?(element) ||
+          matches_html?(element)  ||
+          matches_alt?(element)
+        end
+      end
+
+      def matches_id?(element)
+        (@value.is_a?(Regexp) && element["id"] =~ @value) ||
+        (!@value.is_a?(Regexp) && element["id"] == @value.to_s)
+      end
+
+      def matches_value?(element)
+        element["value"] =~ /^\W*#{Regexp.escape(@value.to_s)}/i
+      end
+
+      def matches_html?(element)
+        element.inner_html =~ /#{Regexp.escape(@value.to_s)}/i
+      end
+
+      def matches_alt?(element)
+        element["alt"] =~ /^\W*#{Regexp.escape(@value.to_s)}/i
+      end
+
+      def button_elements
+        @dom.xpath(*ButtonField.xpath_search)
+      end
+
+      def error_message
+        "Could not find button #{@value.inspect}"
+      end
+
+    end
+
+    def find_button(value) #:nodoc:
+      ButtonLocator.new(@session, dom, value).locate!
+    end
+
+  end
+end

data/lib/webrat/core/locators/field_by_id_locator.rb

@@ -0,0 +1,37 @@
+require "webrat/core/locators/locator"
+
+module Webrat
+  module Locators
+
+    class FieldByIdLocator < Locator # :nodoc:
+
+      def locate
+        Field.load(@session, field_element)
+      end
+
+      def field_element
+        field_elements.detect do |field_element|
+          if @value.is_a?(Regexp)
+            field_element["id"] =~ @value
+          else
+            field_element["id"] == @value.to_s
+          end
+        end
+      end
+
+      def field_elements
+        @dom.xpath(*Field.xpath_search)
+      end
+
+      def error_message
+        "Could not find field with id #{@value.inspect}"
+      end
+
+    end
+
+    def field_with_id(id, *field_types)
+      FieldByIdLocator.new(@session, dom, id, *field_types).locate!
+    end
+
+  end
+end