operawatir 0.4-jruby → 0.4.1-jruby

data/lib/operawatir/desktop_helper.rb

@@ -8,6 +8,8 @@ require 'operawatir'
 require 'rspec'
 require 'rbconfig'
 
+require File.expand_path('../../../spec/operawatir/matchers', __FILE__)
+
 module OperaWatir::DesktopHelper
   extend self
   

data/lib/operawatir/element.rb

@@ -35,9 +35,9 @@ class OperaWatir::Element
     !attr(name).nil?
   end
 
-  def method_missing(name, *args, &blk)
-    if !(block_given? || !args.empty?) && has_attribute?(name)
-      attr(name)
+  def method_missing(method, *args, &blk)
+    if !(block_given? || !args.empty?) && has_attribute?(method)
+      attr(method)
     else
       super
     end
@@ -59,6 +59,8 @@ class OperaWatir::Element
   def_delegator :node, :isEnabled, :enabled?
   def_delegator :node, :isSelected, :checked?
 
+  def_delegator :node, :setSelected, :select
+
   def_delegator :node, :isSelected, :selected?
 
   def_delegator :node, :toggle, :toggle_check!
@@ -66,8 +68,6 @@ class OperaWatir::Element
   def_delegator :node, :getText, :text
   def_delegator :node, :getHTML, :html
 
-  alias_method :to_s, :text
-
   def_delegator :node, :getElementName, :tag_name
   def_delegator :node, :clear, :clear
 
@@ -77,32 +77,54 @@ class OperaWatir::Element
   #
   # @return [String] Value of the element.
   def value
+=begin
     if tag_name =~ /input|textarea|select/i
-      node.getValue
+      node.getValue  #
+    elsif tag_name =~ /button/i
+      text           # getVisibleContents
     else
-      attr :value
+      attr :value    # attribute @value
     end
+=end
+
+    node.getValue
+  end
+
+  #
+  # Does the element exist in the DOM?
+  #
+  # @return [Boolean] True if element exists, false otherwise.
+  #
+
+  def exist?
+    !!!tag_name.empty?
   end
 
+  alias_method :exists?, :exist?  # LOL Ruby
+
   def disabled?
     !enabled?
   end
 
   def check!
-    if not selected?
-      node.toggle
-    end
+    node.toggle if not selected?
   end
 
   def uncheck!
-    if selected?
-      node.toggle
-    end
+    node.toggle if selected?
   end
 
 
   # Events
 
+  #
+  # Clicks on the top left of the element, or the given x,y offset
+  # relative to the element.
+  #
+  # @param [Integer] x The offset from the top left of the element.
+  # @param [Integer] y The offset from the top of the element.
+  #
+
   def click(x=0, y=0)
     node.click(x.to_i, y.to_i)
   end
@@ -137,10 +159,14 @@ class OperaWatir::Element
 
   def_delegator :node, :submit, :submit!
 
-  def text=(string)
-    # Focus before typing
-    clear unless value.empty?
-    node.sendKeys(string.split('').to_java(:string))
+  def text=(input)
+    if attr(:type) =~ /checkbox/i
+      toggle_check! unless checked?
+    else
+      # Focus before typing
+      clear unless value.empty?
+      node.sendKeys(input.to_s.split('').to_java(:string))
+    end
   end
 
   alias_method :set, :text=
@@ -150,6 +176,8 @@ class OperaWatir::Element
     raise Exceptions::NotImplementedException
   end
 
+  # FIXME: This should be migrated to using browserbot.js, as watir-webdriver
+  # is using.
   def fire_event(event, x = 0, y = 0)
     loc = location
     x += loc[:x]
@@ -162,19 +190,15 @@ class OperaWatir::Element
     event = $1 if $1
     event = event.downcase.to_sym
 
-    # TODO Should this be moved to OperaDriver instead?
     case event
-    when :abort, :blur, :change, :error, :focus, :load, :reset,
-      :resize, :scroll, :submit, :unload
+    when :abort, :blur, :change, :error, :focus, :load, :reset, :resize, :scroll, :submit, :unload
       type = 'HTMLEvents';
       init = "initEvent(\"#{event.to_s}\", true, true)"
-    when :click, :dblclick, :mousedown, :mousemove, :mouseout,
-      :mouseover, :mouseup
+    when :click, :dblclick, :mousedown, :mousemove, :mouseout, :mouseover, :mouseup
       type = 'MouseEvents'
       init = "initMouseEvent(\"#{event.to_s}\", true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null)"
     else
-      raise Exceptions::NotImplementedException,
-      "Event on#{event} is not a valid ECMAscript event for OperaWatir."
+      raise Exceptions::NotImplementedException, "Event on#{event} is not a valid ECMAscript event for OperaWatir."
     end
 
     script = "var event = document.createEvent(\"#{type}\"); " +
@@ -185,7 +209,7 @@ class OperaWatir::Element
   end
 
   def visible?
-    node.isVisible()
+    node.isVisible
   end
 
   # UI

data/lib/operawatir/helper.rb

@@ -26,12 +26,12 @@ module OperaWatir::Helper
       settings.each do |key, value|
         config.send("#{key}=", value) if config.respond_to?("#{key}=")
       end
-            
+
       config.include SpecHelpers
       
       config.after(:suite) do
-        browser.quit if browser
-        exit
+        browser.quit if @browser
+        abort
       end
     end
   end
@@ -54,3 +54,5 @@ private
     end
   end
 end
+
+OperaWatir::Helper.run!

data/lib/operawatir/keys.rb

@@ -7,22 +7,27 @@ class OperaWatir::Keys
     self.browser = browser
   end
 
-  # Holds down supplied arbitrary list of keys indefinitely.
   #
-  # @param [Symbol, String] *args Arbitrary list of symbols
-  #   (modification keys) or strings (regular keys) to be pressed
-  #   down.
+  # Holds down supplied arbitrary list of keys indefinitely.
   #
+  # @param [Symbol, String] *args  Arbitrary list of symbols (modification)
+  #                                keys or strings (regular keys) to be
+  #                                pressed down.
+  #                               
   # @example
+  #
   #   browser.keys.down 'a'
   #   browser.keys.down 'a', :right
-  #
+  #  
   # @seealso up
   # @seealso send
+  #
+  
   def down(*args)
     args.each { |key| driver.keyDown(key) }
   end
 
+  #
   # Depresses supplied arbitrary list of keys.
   #
   # @param [Symbol, String] *args Arbitrary list of symbols
@@ -32,19 +37,25 @@ class OperaWatir::Keys
   #   browser.keys.up 'a', :right
   #
   # @seealso release
+  #
+
   def up(*args)
     args.each { |key| driver.keyUp(key) }
   end
 
+  #
   # Releases all pressed down keys.
   #
   # @example
   #   browser.keys.down :control, :shift, 'a'
   #   browser.keys.release
+  #
+
   def release
     driver.releaseKeys
   end
 
+  #
   # Presses an arbitrary list of keys or key combinations.  Provided
   # arguments are performed in sequence.
   #
@@ -70,6 +81,8 @@ class OperaWatir::Keys
   #   browser.keys.send :control
   #   browser.keys.send [:control, 'a']
   #   browser.keys.send [:control, 'a'], :backspace
+  #
+
   def send(*list)  # TODO rename?
     list.each do |item|
       case item
@@ -82,9 +95,9 @@ class OperaWatir::Keys
             down key
           else
             key key
-            release
           end
         end
+        release
       when Symbol
         key item
       else

data/lib/operawatir/preferences.rb

@@ -1,23 +1,110 @@
-require 'inifile'
-require 'tmpdir'
-require 'pp'
-require 'active_support/inflector'
-
+# -*- coding: utf-8 -*-
 class String
-  def keyize
-    self.humanize.titleize
-  end
+
+  #
+  # Translates an Opera preferences key string into a Ruby method name.
+  # It will remove tabs and spaces at beginning of string, replace
+  # further spaces with an underscore and make the string lower-case.
+  #
+  # The method extends the String object and can be called as a regular
+  # method on any string in Ruby.
+  #
 
   def methodize
-    self.titleize.gsub(/\s+/, '').underscore
+    self.gsub(/^\\t(\s+)/, '').gsub(/\s+/, '_').downcase
+  end
+
+  #
+  # Translates a previously keyized Opera preferences method string into
+  # an Opera preferences key string.  This is done by replacing
+  # underscores with spaces and capitalizing each word in the string.
+  #
+  # The method extends the String object and can be called as a regular
+  # method on any string in Ruby.
+  #
+
+  def keyize
+    self.gsub(/_/, ' ').gsub(/\b('?[a-z])/) { $1.capitalize }
   end
 end
 
+#
+# OperaWatir::Preferences enables you to access the browser preferences
+# in the Opera web browser.
+#
+# @example
+#
+#   The Preferences object is created automatically when creating a new
+#   Browser object and is exposed as an interface on that object:
+#
+#     browser.preferences
+#     => <OperaWatir::Preferences>
+#
+#   You can interact with this object as you would with any Ruby object.
+#   Sections and entries are exposed as Rubyized method names, which
+#   means that you can access them like this:
+#
+#     browser.preferences.interface_colors             # a section
+#     browser.preferences.interface_colors.background  # an entry
+#
+#   Over the preference object itself or over a section you can also use
+#   built-in Ruby convenience methods such as:
+#
+#     browser.preferences.first             # first section
+#     browser.preferences.interface_colors  # first entry in section
+#     browser.preferences.size              # number of sections
+#
+#   This is a full list of available convenience methods:
+#
+#     * []
+#     * each
+#     * length
+#     * size
+#     * first
+#     * last
+#     * empty?
+#
+#   Essentially, the preference and section objects are collections
+#   (kind of like arrays) that allows you to also iterate over them:
+#
+#     browser.preferences.each_with_index do |section, index|
+#       puts "Section No. #{index} is called `#{section.key}'"
+#     end
+#
+#     browser.preferences.interface_colors.each { |e| e.value = '#cccccc' }
+#
+#     browser.preferences.interface_colors[5].value
+#     => '#cccccc'
+#
+#   On each section, the follow getters are available in addition to the
+#   convenience methods mentioned above:
+#
+#     * section?  # Returns true/false based on whether it's a section
+#     * exists?   # Returns true/false based on whether it exists
+#
+#   On each entry, the following getters and setters are available in
+#   addition to the convenience methods mentioned above:
+#
+#     * value     # Returns current preference's value
+#     * value=    # Sets current preference's value to provided string
+#     * default   # Returns current preference's default
+#     * default!  # Sets current preference to its default
+#
+#   This means you can do crazy stuff like resetting all the preferences
+#   in `opera:config` to their standard value like this:
+#
+#     browser.preferences.each do |section|
+#       section.each do |entry|
+#         entry.default!
+#       end
+#     end
+#
+
 class OperaWatir::Preferences
   extend Forwardable
   include Enumerable
 
-  attr_accessor :browser
+  attr_accessor :browser, :driver
 
   # FIXME This should be retrievable from OperaDriver
   SECTIONS = ['Author Display Mode', 'Auto Update', 'BitTorrent',
@@ -32,61 +119,113 @@ class OperaWatir::Preferences
               'User Agent', 'User Display Mode', 'User Prefs', 'Visited Link',
               'Visited Link', 'Web Server', 'Widgets', 'Workspace']
 
+  #
+  # The OperaWatir::Preferences object is created automatically when you
+  # create an OperaWatir::Browser object, and is available as
+  # Browser#prefrences.
+  #
+  # @example
+  #
+  #   browser.preferences.method_name
+  #
+  # @param [Object] browser  An OperaWatir::Browser object.
+  #
+
   def initialize(browser)
-    self.browser = browser
+    self.browser, self.driver = browser, browser.driver
   end
 
-  # Section locator
+  #
+  # When calling Preferences#any_method_name, the `any_method_name` will
+  # be caught by this method.
+  #
+  # This is the standard way of looking up sections.  `any_method_name`
+  # should be replaced by a methodized version of the section as it
+  # appears in the Opera preferences list which you can find at
+  # `opera:config`.
+  #
+  # @example
+  #
+  #   browser.preferences.interface_colors
+  #   # will return section “Interface Colors”
+  #
+  # @param           section  Method to look up in preferences.
+  # @return [Object]          A Preferences::Entry (section) object.
+  #
+
   def method_missing(section)
-    # @_prefs[section.to_s] ||= Entry.new self, section
-    Entry.new self, section
+    if _prefs.any? { |s| s.method == section.to_s }
+      _prefs.find { |s| s.method == section.to_s }
+    else
+      _prefs << Entry.new(self, section)
+      _prefs.last
+    end
   end
 
-  def cleanup; end
-  def cleanup!; end
+  def_delegators :_prefs, :[],
+                          :each,
+                          :length,
+                          :size,
+                          :first,
+                          :last,
+                          :empty?
+
+  #
+  # Retrieves a human-readable list of Opera preferences available.
+  # This is used for convenience and should never be parsed.  Consider
+  # using the built-in Ruby iterator #each (with friends) or
+  # Preferences#to_a for that.
+  #
+  # @return [String]          List of preferences.
+  #
 
-  def_delegators :sections, :each,
-                            :length,
-                            :size,
-                            :first,
-                            :last,
-                            :empty?
+  def to_s
+    text = ''
 
-  alias_method :each_section, :each
+    _prefs.each do |s|
+      text << "#{s.method}\n"
 
-  def to_s
-    pp _prefs
-  end
+      s.each do |k|
+        text << "  #{k.method}\n"
+        text << "    type:     #{k.type.inspect}\n"
+        text << "    value:    #{k.value.inspect}\n"
+        text << "    default:  #{k.default.inspect}\n"
+      end
+    end
 
-  def to_h
-    _prefs.dup
+    text
   end
 
-private
-  def sections
-#    @_prefs ||= all_prefs
-    all_prefs
-  end
+  #
+  # Returns a list of all preferences in array form.  This can be used
+  # for external parsing.  If you wish to manipulate or iterate through
+  # the list of preferences consider using the built-in Ruby iterator
+  # #each (with friends).
+  #
+  # @return [Array]           List of preferences.
+  #
 
-  def all_prefs
-    list = []
-    SECTIONS.each { |s| list << Entry.new(self, s.methodize) }
-    list
+  def to_a
+    _prefs.dup
   end
 
-  def load_from_file(file)
-    inifile = Loader.new file
-    loaded_prefs = IniFile.new inifile.output.path
+  #
+  # Checks if any preferences exists in your Opera build.  If true,
+  # there are preferences available, false otherwise.
+  #
+  # @return [Boolean]         Whether any preferences exists.
+  #
 
-    loaded_prefs.each_section do |s|
-      s.each do |k,v|
-        driver.setPref s,k,v
-      end
-    end
+  def exists?
+    !_prefs.empty?
   end
+  
+  alias_method :exist?, :exists?  # LOL Ruby
 
-  def driver
-    browser.driver
+private
+
+  def _prefs
+    @_prefs ||= SECTIONS.map { |s| Entry.new(self, s.methodize, s) }
   end
 
 
@@ -94,66 +233,164 @@ private
     extend Forwardable
     include Enumerable
 
-    attr_accessor :parent, :method, :key, :value
-
-    def initialize(parent, method)
-      self.parent, self.method, self.key = parent, method, method.to_s.keyize
+    attr_accessor :parent, :method, :key, :value, :type, :default, :driver
+
+    #
+    # OperaWatir::Preferences::Entry is the object that represents
+    # either a section or a section's entry.
+    #
+    # It's created automatically when you query for entries using the
+    # Preference object itself.
+    #
+    # @return [Object] An OperaWatir::Preferences::Entry object.
+    #
+
+    def initialize(parent, method, key=nil, type=nil)
+      self.parent = parent
+      self.method = method.to_s
+      self.key    = key ? key : method.to_s.keyize
+      self.type   = type
+      self.driver = parent.driver
     end
 
-    def method_missing(key)
-      Entry.new self, key
+    #
+    # When calling Preferences::Entry#any_method_name, the
+    # `any_method_name` will be caught by this method.
+    #
+    # This is the standard way of looking up preference entries.
+    # `any_method_name` should be replaced by a methodized version of
+    # the entry as it appears in the Opera preferences list which you
+    # can find at `opera:config`.
+    #
+    # @example
+    #
+    #   browser.preferences.interface_colors.background
+    #   # will return the “Background” entry in section “Interface Colors”
+    #
+    # @param           method  Method to look up in section.
+    # @return [Object]         A Preferences::Entry (entry) object.
+    #
+
+    def method_missing(method)
+      method = method.to_s
+      
+      if _keys.any? { |k| k.method == method }
+        _keys.find { |k| k.method == method }
+      else
+        _keys << Entry.new(self, method)
+        _keys.last
+      end
     end
 
+    #
+    # Returns the value of an entry in a section.  Note that it's not
+    # possible to retrieve the value for sections.
+    #
+    # @return [String] Value of the entry.
+    #
+
     def value
-      return nil if is_section?
-      @value ||= driver.getPref parent.key, @key
+      raise OperaWatir::Exceptions::PreferencesException, 'Sections do not have values' if section?
+      @value ||= driver.getPref(parent.key, key)
     end
 
+    #
+    # Sets the entry's value to the specified string.  Note that it's
+    # not possible to set a section's value.
+    #
+    # @param [String] value  Value you wish to set for the entry.
+    #
+
     def value=(value)
-      raise OperaWatir::Exceptions::PreferencesException, 'Sections cannot have values'
-      driver.setPref parent.key, @key, value
+      raise OperaWatir::Exceptions::PreferencesException, 'Sections cannot have values' if section?
+      value = value.truthy? ? '1' : '0' if type.include?('Boolean')
+      driver.setPref parent.key, key, value.to_s
+      @value = value
     end
 
+    #
+    # Returns entry's default value.  Note that it's not possible to
+    # return a section's default value.
+    #
+    # @return [String]       The default value of the entry.
+    #
+
     def default
-      return nil if is_section?
-      @default ||= driver.getDefaultPref parent.key, @key
+      raise OperaWatir::Exceptions::PreferencesException, 'Sections do not have defaults' if section?
+      @default ||= driver.getDefaultPref parent.key, key
     end
 
+    #
+    # Returns and sets the default value of the entry.  Note that it's
+    # not possible to return and set a section's default value.
+    #
+    # @return [String]       The default value of the entry.
+    #
+
     def default!
-      raise OperaWatir::Exceptions::PreferencesException, 'Sections do not have defaults'
-      value=(default)
+      self.value=(default)  # WTF?  Bug in Ruby?
     end
 
-    def each_key
-      return unless block_given?
-      raw_keys.each { |k| yield k }
+    #
+    # Is the current node a section?
+    #
+    # @return [Boolean]      True/false based on whether you're
+    #                        interacting with a section or entry.
+    #
+
+    def section?
+      parent.kind_of? OperaWatir::Preferences
     end
 
-    alias_method :each, :each_key
+    #
+    # Does this entry/section exist?
+    #
+    # @return [Boolean]      True/false based on whether the method you
+    #                        are attempting to access exists as a
+    #                        preference entry/section.
+    #
 
-    def is_section?
-      @parent.kind_of? OperaWatir::Preferences
+    def exists?
+      section? ? SECTIONS.include?(key) : !type.empty?
     end
 
-  private
-    def driver
-      @parent.browser.driver || @parent.parent.browser.driver
+    alias_method :exist?, :exists?  # LOL Ruby
+
+    def each
+      return unless block_given?
+      _keys.each { |k| yield k }
     end
 
-    def raw_keys
+    def_delegators :_keys, :[],
+                           :length,
+                           :size,
+                           :first,
+                           :last,
+                           :empty?
+
+  private
+
+    def _keys
+      raise OperaWatir::Exceptions::PreferencesException, 'Keys are not iteratable objects' if not section?
       @_keys ||= all_keys
     end
 
     def all_keys
+      return if not section?
       keys = []
 
-      driver.listPrefs(true, @key).to_a.each do |data|
-        data = data.to_s
-
-        data =~ /^key: \"([a-zA-Z0-9\(\)\\\.\-\s]*)\"/
-        key = $1.gsub(/\\t/, '')
-
-        keys << Entry.new(self, key.methodize)
+      driver.listPrefs(true, key).to_a.each do |p|
+        p = p.to_s
+        
+        p =~ /^key: \"([a-zA-Z0-9\(\)\\\.\-\s]*)\"$/
+        key = $1.to_s.gsub(/^\\t/, "\t")  # Workaround for double-encoded tabs:
+                                          # We get \\t, but it only accepts \t.
+        
+        p =~ /^type: ([A-Z]+)$/
+        type = $1.to_s.capitalize
+
+        next if key.empty?  # “Opera Widgets/Unite Style File” is bugged, workaround.
+        keys << Entry.new(self, key.methodize, key, type)
       end
 
       keys