operawatir 0.3-jruby

data/lib/operawatir/collection.rb

@@ -0,0 +1,133 @@
+require 'forwardable'
+require 'set'
+
+class OperaWatir::Collection
+  extend Forwardable
+  include Enumerable
+
+  attr_accessor :parent, :selector
+
+  def initialize(parent, elms=nil)
+    self.parent, self.selector = parent, OperaWatir::Selector.new(self)
+    @_elms = elms
+  end
+
+  def add_selector_from_arguments(args)
+    if not args.empty?
+      args.each do |arg|
+        selector.attribute arg
+      end
+    end
+  end
+
+  def exist?
+    !raw_elements.empty?
+  rescue OperaWatir::Exceptions::UnknownObjectException
+    false
+  end
+  alias_method :exists?, :exist? # LOL Ruby
+
+  def single?
+    raw_elements.length == 1
+  end
+
+  def_delegators :raw_elements, :each,
+                                :length,
+                                :size,
+                                :first,
+                                :last,
+                                :empty?
+
+
+  def [](n)
+    self.class.new(self).tap {|c| c.selector.index(n) }
+  end
+
+  # Set union, used for joining complex finders (specifically for Watir1)
+  def +(other)
+    self.class.new(parent, raw_elements + other.raw_elements)
+  end
+
+  # Public interface to elms, used in Selector
+  def raw_elements
+    _elms.tap do |e|
+      raise(OperaWatir::Exceptions::UnknownObjectException) if e.empty?
+    end
+  end
+
+
+  # Attributes
+
+  def id
+    map_or_return {|elm| elm.id}
+  end
+
+  def attr(name)
+    raw_elements[0].attr(name)
+  end
+
+  def attrs(name)
+    raw_elements.map do |el|
+      el.attr(name)
+    end
+  end
+
+
+  # Finding
+
+  OperaWatir::Selector::BASE_TYPES.each do |type|
+    define_method("find_by_#{type}") do |name|
+      OperaWatir::Collection.new(self).tap do |c|
+        c.selector.send(type, name)
+      end
+    end
+  end
+
+  alias_method :find_by_class, :find_by_class_name
+  alias_method :find_by_tag,   :find_by_tag_name
+
+  # TODO
+  #   - Find tag if method exists in a list of HTML5 elements
+  #   - If ends in ? then check that all returned values are true
+  #   - Else, return attributes from elements
+  def method_missing(method, *args, &blk)
+    map_or_return {|elm| elm.send(method, *args, &blk) }
+  end
+
+
+private
+
+  def _elms
+    @_elms ||= selector.eval
+  end
+
+  attr_writer :_elms
+
+  # TODO Massive hack: map is overritten in Watir1
+  alias_method :_map, :map
+
+  def map_or_return(&blk)
+    single? ? blk.call(raw_elements.first) : _map(&blk)
+  end
+
+  OperaWatir::Selector::BASE_TYPES.each do |type|
+    define_method("find_elements_by_#{type}") do |value|
+      _elms.inject([]) do |result, element|
+        result | element.send("find_elements_by_#{type}", value.to_s)
+      end
+    end
+  end
+
+  def find_elements_by_attribute(attributes)
+    _elms.select do |elm|
+      attributes.all? {|attribute, value|
+        elm.send(attribute).send((value.is_a?(Regexp) ? :match : :==), value)
+      }
+    end
+  end
+
+  def find_elements_by_index(n)
+    (n >= 0 && n < _elms.length) ? [_elms[n]] : []
+  end
+
+end

data/lib/operawatir/compat.rb

@@ -0,0 +1,25 @@
+module OperaWatir
+  
+  module Compat; end
+
+  # Switches on compatibility layer (Watir 1 API).
+  def self.compatibility!
+    # require 'operawatir/compat/deprecation'
+    require 'operawatir/compat/browser'
+    require 'operawatir/compat/element_finders'
+    require 'operawatir/compat/window'
+    
+    Browser.send :include, Compat::Browser
+    Window.send :include, Compat::ElementFinders
+    Window.send :include, Compat::Window
+    Collection.send :include, Compat::ElementFinders
+    
+    # TODO Ruby Modules can't override methods defined in their included klass
+    #   Requiring the files is OK, but there needs to be some way of detecting
+    #   that we are in compatibility mode.
+    
+    require 'operawatir/compat/collection'
+    require 'operawatir/compat/element'
+  end
+  
+end

data/lib/operawatir/compat/browser.rb

@@ -0,0 +1,20 @@
+module OperaWatir
+  module Compat
+    module Browser
+
+      def method_missing(method, *args, &blk)
+        if active_window.respond_to? method
+          active_window.send(method, *args, &blk)
+        else
+          super
+        end
+      end
+
+      # Quits the browser
+      def quit
+        browser.quit!
+      end
+
+    end
+  end
+end

data/lib/operawatir/compat/collection.rb

@@ -0,0 +1,99 @@
+class OperaWatir::Collection
+
+  # Aliases that Watir1 defines for certain attributes
+  ATTRIBUTE_ALIASES = {
+    :url => :href,
+    :class => :class_name,
+    :tag => :tag_name
+  }
+
+  # Welcome to Hacksville, population: too many
+
+  # Creates a new selector based on the arguments given to the Watir 1
+  # browser methods, e.g. +browser.div(:id, 'content')+.
+  #
+  # @param [Array] args The array of arguments passed to the Watir
+  #   method.
+  # @param [Method] default_method The attribute to use when only a
+  #   value is provided, e.g. browser.div('content').
+  # @return [OperaWatir::Selector] the generated selector
+  def add_selector_from_arguments(args, default_method)
+    # () => :index, 0
+    if args.empty?
+      type, value = :index, 0
+
+    # (:index, 1) => :index, 0
+    elsif args.first == :index
+      type, value = :index, args[1].to_i - 1
+
+	# Handle a hash of selectors
+    elsif args.length == 1 and  args.first.is_a? Hash
+      args.first.each_pair do |k, v|
+        s = add_selector_from_arguments([k, v], default_method)
+      end
+      return s
+
+    # (:id, 3.14) => TypeError
+    elsif args.any? {|arg| ![String, Regexp, Fixnum, Symbol].any?{|k| arg.is_a?(k)}}
+      raise TypeError
+
+    # NOTE: This is purely to make WatirSpec pass
+    # (:no_such_how, 'some_value') => Exception
+    elsif args.first == :no_such_how
+      raise OperaWatir::Exceptions::MissingWayOfFindingObjectException
+
+    # ('foo') => :attribute, {:id => 'foo'}
+    elsif !args.first.is_a?(Symbol) && args[1].nil?
+      type, value = :attribute, {
+        default_method => args.first
+      }
+
+    # (:xpath, '//area') => :xpath, '//area'
+    elsif ![:id, :class, :tag].include?(args.first) && OperaWatir::Selector::BASE_TYPES.include?(args.first)
+      type, value = args.first, args[1]
+
+    # (:url, 'foo.html') => :attribute, {:href => 'foo.html'}
+    else
+      type, value = :attribute, {
+        (ATTRIBUTE_ALIASES[args.first.to_sym] || args.first) => args[1]
+      }
+    end
+
+    selector.send(type, value)
+  end
+
+  # Watir1 Collections are 1 indexed *headslap*
+
+  # Gets the element at index, starting from 1 (i.e. [0] in a normal
+  # array is [1] here.
+  #
+  # @param [Fixnum] index The index of the element to retreive
+  # @return [OperaWatir::Collection] A new collection with the
+  #   selector pointing to the given index.
+  def [](index)
+    self.class.new(self).tap {|c| c.selector.index(index-1) }
+  end
+
+  # Define methods to satisfy #respond_to? which is used in the tests.
+  [:name, :title, :type, :class_name, :text, :style, :value].each do |name|
+    define_method(name) {method_missing(name)}
+  end
+
+  # Fetches the string representation of this collection.
+  #
+  # @return [String] the string representation of this collection
+  # @raise [OperaWatir::Exceptions::UnknownObjectException]
+  def to_s
+    # This should return all of the attributes defined on each
+    # element. We don't have support for that, so lets just
+    # output the useful ones.
+    raw_elements.map do |el|
+      "tag:          #{el.tag_name.downcase}\n"+
+      "  id:           #{el.id}\n" +
+      "  class:        #{el.class_name}\n" +
+      "  title:        #{el.title}\n" +
+      "  text:         #{el.text}"
+    end.join("\n")
+  end
+
+end

data/lib/operawatir/compat/deprecation.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+
+class OperaWatir::Exceptions::DeprecationException < OperaWatir::Exceptions::OperaWatirException
+  
+  def initialize(desc, fix, trace)
+    @desc, @fix = desc, fix
+    set_backtrace clean_backtrace(trace)
+  end
+  
+  def message
+    "DEPRECATION: #{@desc}\n  #{@fix}"
+  end
+
+private
+
+  LIB_PATHS = [File.expand_path('../../../', __FILE__)] + Gem.all_load_paths
+
+  def clean_backtrace(trace)
+    trace.reject do |line|
+      LIB_PATHS.any? do |lib_path|
+        line.include?(lib_path)
+      end || line.split(':').first == ''
+    end
+  end
+  
+end
+
+module OperaWatir
+  module Compat
+    module Deprecation
+      
+      def deprecation(desc, fix)
+        warn OperaWatir::Exceptions::DeprecationException.new(desc, fix, caller).message
+      end
+  
+      def deprecation!(desc, fix)
+        raise OperaWatir::Exceptions::DeprecationException.new(desc, fix, caller)
+      end
+      
+    end
+  end
+end
+
+class Object
+  include OperaWatir::Compat::Deprecation
+end

data/lib/operawatir/compat/element.rb

@@ -0,0 +1,165 @@
+class OperaWatir::Element
+
+  # Gets the attribute called name.
+  #
+  # @param [String, Symbol] name The name of the attribute to get
+  # @return [String] The value of the attribute
+  def attr(name)
+    node.getAttribute(name.to_s) || ''
+  end
+
+  # Check the existence of the attribute on the element.
+  #
+  # @return [Boolean] true if the attribute exists on the element,
+  #   false otherwise
+  def attr?(name)
+    !node.getAttribute(name.to_s).nil?
+  end
+
+  def method_missing(name, *args, &blk)
+    if !block_given? && args.empty?
+      attr(name)
+    else
+      super
+    end
+  end
+
+  # Gets the text content of the element.
+  #
+  # @return [String] the text content
+  def text
+    node.getText.strip
+  end
+
+  alias_method :to_s, :text
+
+  # On elements of type `<input>` this gets the value of the value
+  # attribute, on every other element type it returns the text
+  # content.
+  #
+  # @return [String] value of the element
+  def value
+    if tag_name == 'INPUT' or attr?(:value)
+      attr(:value)
+    else
+      text
+    end
+  end
+
+  # Checks whether the text content of the element contains the given
+  # string In the compatibility layer as the preferred way of doing
+  # this is.
+  #
+  #   elm.text.should include('My string')
+  #
+  # @param [String] String to search for
+  # @param [Boolean] true if the element's text contains str, false
+  #   otherwise
+  def verify_contains(str)
+    text.include?(str)
+  end
+
+  alias_method :verify_contains?, :verify_contains
+
+  alias_method :caption, :text
+
+  # Clicks on the top left of the element, or the given x, y offset.
+  #
+  # @param [optional, Fixnum] x The offset from the left of the
+  #   element
+  # @param [optional, Fixnum] y The offset from the top of the element
+  def click(x=0, y=0)
+    assert_enabled!
+    node.click(x.to_i, y.to_i)
+  end
+
+  # Focuses the element
+  def focus
+    trigger! :focus
+  end
+
+  alias_method :fire_event, :trigger!
+
+  # Submits a form, or the form the elment is contained in.
+  def submit
+    assert_exists
+    node.submit
+  end
+
+  # Clears a text input or textarea of any text.
+  def clear
+    assert_enabled!
+    node.clear
+  end
+
+  # If passed a value it will type text into the element, otherwise it
+  # will check a radio button or checkbox.
+  #
+  # @param [optional, String] value Text to type
+  def set(value=nil)
+    if value
+      self.text = value
+    else
+      check!
+    end
+  end
+
+  # Gets the href of an `<a>` element, or the url attribute of any
+  # other element.
+  #
+  # @return [String] an href or the url attribute
+  def url
+    attr(tag_name == 'A' ? :href : :url)
+  end
+
+  # Gets the selected `<option>` elements in a `<select>` element.
+  #
+  # @return [OperaWatir::Collection] a collection of the selected
+  #   `<option>`s
+  def selected_options
+    options(:selected?, true)
+  end
+
+  # On checkboxes, radio buttons, and option elements returns whether
+  # the element is checked/selected. On a select element, when passed
+  # an value it checks whether the selected option contains the given
+  # text.
+  #
+  # @param [optional, String] value Text the selected option should
+  #   contain
+  # @return [Boolean] true if the element is selected/selected option
+  #   contains value, false otherwise
+  def selected?(value=nil)
+    if option.nil?
+      selected_options.text.include?(value)
+    else
+      node.isSelected
+    end
+  end
+
+  # For `<select>` elements returns either 'select-one' for
+  # `<select>`s where only a single `<option>` can be selected, or
+  # 'select-multiple' otherwise.  For non-`<select>` elements returns
+  # the `type` attribute.
+  def type
+    if tag_name == 'SELECT'
+      attr(:multiple) == 'multiple' ? 'select-multiple' : 'select-one'
+    else
+      attr(:type)
+    end
+  end
+
+  # Gets the colspan attribute as an integer.
+  #
+  # @return [Fixnum] the colspan
+  def colspan
+    attr(:colspan).to_i
+  end
+
+private
+
+  def assert_enabled!
+    raise OperaWatir::Exceptions::ObjectDisabledException if disabled?
+  end
+
+end