operawatir 0.3.2-jruby → 0.3.7.pre1-jruby

data/lib/operawatir/desktop-waiter.rb

@@ -1,144 +1,2 @@
 # -*- coding: utf-8 -*-
-
-require 'rspec'
-require 'rbconfig'
-require 'ostruct'
-
-class Object
-  def truthy?
-
-    # FIXME: Should we not check for truthfulness instead, and presume
-    # that anything else passed to be false?  Below we are doing the
-    # opposite.
-    #self && !['false', 'no', 'n', '0', 0].include?(self)
-
-    self && [true, 'true', 'yes', 'y', '1', 1].include?(self)
-  end
-end
-
-
-module OperaWatir::Waiter
-  extend self
-
-  def self.default_attr_accessor(attr, default)
-    define_method attr.to_sym do
-      default || instance_variable_get("@#{attr}") || ENV["OPERA_#{attr.to_s.upcase}"]
-    end
-    attr_writer attr.to_sym
-  end
-
-  def defaults
-    configure do |c|
-      c.path          = nil
-      c.args          = ''
-      c.files         = "file://localhost/#{File.expand_path('interactive', File.dirname(RSpec.configuration.files_to_run[0]))}"
-      c.inspectr      = false
-      c.terminal_size = [80,24]
-    end
-  end
-
-  def configure(*args, &block)
-    HelperConfig.block_to_hash(block).each do |setting, value|
-      default_attr_accessor setting, value
-    end
-  end
-
-  class HelperConfig < OpenStruct
-    def self.block_to_hash(block=nil)
-      config = self.new
-      if block
-        block.call(config)
-        config.to_hash
-      else
-        {}
-      end
-    end
-    
-    def to_hash
-      @table
-    end
-  end
-
-  defaults
-
-  def browser
-    @browser ||= OperaWatir::DesktopBrowser.new(path, *args.split(' ').to_java(:string))
-  end
-  
-  def helper_file
-    File.expand_path(File.join(Dir.pwd, 'helper.rb'))
-  end
-
-  def configure_rspec
-    RSpec.configure do |config|
-      config.include SpecHelpers
-
-      config.after(:suite) do
-        # Only exit if the envrionment variable is set
-        if ENV["OPERA_PATH"].to_s.length > 0
-          OperaWatir::Waiter.browser.quit
-        else
-          # Just shutsdown the driver
-          OperaWatir::Waiter.browser.quit_driver
-        end
-      end
-      config.before(:all) do
-        #set_prefs
-      end
-      config.after(:all) do
-        #delete_prefs
-      end
-    end
-  end
-  
-  def inspectr_path
-    File.join File.expand_path('../../../utils', __FILE__),
-              (Config::CONFIG['host_os'] =~ /mswin|msys|mingw32/ ? 'inspectr.exe' : 'inspectr')
-  end
-  
-  def spawn_inspectr
-    abort 'operawatir: inspectr is not supported on your operating system' unless Config::CONFIG['host_os'] =~ /linux/
-    abort 'operawatir: Unable to locate inspectr executable' unless File.exist?(inspectr_path)
-    
-    Thread.new do
-      puts "Attaching inspectr to PID ##{browser.pid}"
-      exec inspectr_path, browser.pid.to_s
-    end
-  end
-  
-  def run!
-    require helper_file if File.exist?(helper_file)
-    spawn_inspectr if inspectr.truthy?
-    configure_rspec
-    RSpec::Core::Runner.autorun
-  end
-
-  
-  # Helpers included for each Spec
-  
-  module SpecHelpers
-    def browser
-      OperaWatir::Waiter.browser
-    end
-
-    # TODO Not sure of this
-    def files(new_path=nil)
-      if new_path
-        OperaWatir::Waiter.files = new_path
-      else
-        OperaWatir::Waiter.files
-      end
-    end
-    alias_method :files=, :files
-  end
-end
-
-# Overriding trapping in RSpec.
-module RSpec
-  module Core
-    class Runner
-      def self.trap_interrupt; end
-    end
-  end
-end
-
+require 'operawatir/desktop_helper'

data/lib/operawatir/desktop_browser.rb

@@ -8,12 +8,11 @@ module OperaWatir
       "Open url in new window"]
     
     # @private
-    def initialize (executable_location = nil, *arguments)
-      if executable_location.nil? or executable_location.length == 0
-        @driver = OperaDesktopDriver.new
-      else
-        @driver = OperaDesktopDriver.new(executable_location, arguments.to_java(:String))
-      end
+    def initialize
+      OperaWatir.compatibility! unless OperaWatir.api >= 2
+
+      self.driver = OperaDesktopDriver.new(self.class.opera_driver_settings)
+      self.active_window = OperaWatir::Window.new(self)
     end
 
     # @private
@@ -21,15 +20,30 @@ module OperaWatir
     # dialogs to autoclose in Dialog.cpp when then OnUrlChanged is fired 
     # after a dialog is opened
     def goto(url = "")
-      super
+      super #active_window.url = url
       sleep(1)
     end
 
+    ######################################################################
+    # Quits Opera
+    #
+    def quit_opera
+      driver.quitOpera
+    end
+    
+    ######################################################################
+    # Restarts Opera
+    #
+    def restart
+      driver.quitOpera
+      driver.startOpera
+    end
+
     ######################################################################
     # Quits the driver without exiting Opera
     #
-    def quit_driver()
-      @driver.shutdown
+    def quit_driver
+      driver.quitDriver
     end
       
     ######################################################################
@@ -226,7 +240,7 @@ module OperaWatir
     # @return [Array] Array of widgets retrieved from the window
     #
     def widgets(win_name)
-      @driver.getQuickWidgetList(win_name).map do |java_widget|
+      driver.getQuickWidgetList(win_name).map do |java_widget|
         case java_widget.getType
           when QuickWidget::WIDGET_ENUM_MAP[:button]
             QuickButton.new(self,java_widget)
@@ -254,13 +268,15 @@ module OperaWatir
       end.to_a
     end
    
+    alias_method :quick_widgets, :widgets
+    
     ####################################################
     # Retrieves an array of all windows 
     #
     # @return [Array] Array of windows
     #
-    def windows
-      @driver.getWindowList.map do |java_window|
+    def quick_windows
+      driver.getQuickWindowList.map do |java_window|
         QuickWindow.new(self,java_window)
       end.to_a
     end
@@ -268,7 +284,7 @@ module OperaWatir
     #@private
     # Retrieve all tabs
     def open_pages
-      windows.select { |win| win.name == "Document Window" }
+      quick_windows.select { |win| win.name == "Document Window" }
     end
     
     #@private
@@ -304,8 +320,8 @@ module OperaWatir
     #
     # @return [String] Name of the window
     #
-    def get_window_name(win_id)
-      @driver.getWindowName(win_id)
+    def window_name(win_id)
+      driver.getQuickWindowName(win_id)
     end
      
     ######################################################################
@@ -352,8 +368,8 @@ module OperaWatir
     #
     # @return [String] Full path to the opera executable 
     #
-    def get_opera_path
-      @driver.getOperaPath()
+    def path
+      driver.getOperaPath()
     end
 
     ######################################################################
@@ -361,8 +377,8 @@ module OperaWatir
     #
     # @return [String] Full path to the large preferences folder
     #
-    def get_large_preferences_path
-      @driver.getLargePreferencesPath()
+    def large_preferences_path
+      driver.getLargePreferencesPath()
     end
   
     ######################################################################
@@ -370,8 +386,8 @@ module OperaWatir
     #
     # @return [String] Full path to the small preferences folder
     #
-    def get_small_preferences_path
-      @driver.getSmallPreferencesPath()
+    def small_preferences_path
+      driver.getSmallPreferencesPath()
     end
   
     ######################################################################
@@ -379,8 +395,8 @@ module OperaWatir
     #
     # @return [String] Full path to the cache preferences folder
     #
-    def get_cache_preferences_path
-      @driver.getCachePreferencesPath()
+    def cache_preferences_path
+      driver.getCachePreferencesPath()
     end
 
     ######################################################################
@@ -392,6 +408,11 @@ module OperaWatir
       Config::CONFIG['target_os'] == "darwin"
     end
     
+    ######################################################################
+    # Returns true if the test is running on Linux 
+    #
+    # @return [Boolean] true we the operating system is Linux, otherwise false 
+    #
     def linux?
        Config::CONFIG['target_os'] == "linux"
      end
@@ -469,13 +490,13 @@ module OperaWatir
     # Close all open dialogs
     #
     def close_all_dialogs
-      win_id = driver.getActiveWindowID()
+      win_id = driver.getActiveQuickWindowID()
       until quick_window(:id, win_id).type != :dialog do
-        win = quick_window(:id, driver.getActiveWindowID())
+        win = quick_window(:id, driver.getActiveQuickWindowID())
         if win.type == :dialog
           close_dialog(win.name)
-          if (driver.getActiveWindowID() != win_id)
-            win_id = driver.getActiveWindowID()
+          if (driver.getActiveQuickWindowID() != win_id)
+            win_id = driver.getActiveQuickWindowID()
           else
             break
           end
@@ -483,14 +504,40 @@ module OperaWatir
       end
     end
     
+    ############################################################################
+    #
+    # Reset prefs
+    #
+    # Quits Opera and copies prefs from src to dest, then restarts Opera with the
+    # new Prefs
+    #
+    def reset_prefs(new_prefs)
+      driver.resetOperaPrefs(new_prefs)
+    end
+    
+    ##############################################################################
+    #
+    # Deletes profile for the connected Opera instance.
+    # Should only be called after quitting (and before starting) Opera.
+    #
+    #
+    def delete_profile
+      driver.deleteOperaPrefs
+    end
     
-=begin  
-  TODO:  
-  def delete_cookies
-  def reset_main_window
-=end    
-  
 private
+
+   def self.opera_driver_settings
+     @opera_driver_settings ||= OperaDriverSettings.new.tap {|s|
+       s.setRunOperaLauncherFromOperaDriver true
+       s.setOperaLauncherBinary self.settings[:launcher]
+       s.setOperaBinaryLocation self.settings[:path]
+       s.setOperaBinaryArguments self.settings[:args] + ' -watirtest'
+       s.setNoQuit self.settings[:no_quit]
+       s.setNoRestart self.settings[:no_restart]
+     }
+   end
+   
     # Gets the parent widget name of which there is none here
     def parent_widget
       nil

data/lib/operawatir/desktop_enums.rb

@@ -17,24 +17,24 @@ module OperaWatir
 
     # Enum for the widget types
     WIDGET_ENUM_MAP = DesktopWmProtos::QuickWidgetInfo::QuickWidgetType.constants.inject({}) do |acc, const|
-      #puts const.inspect
       acc[const.to_s.downcase.to_sym] = DesktopWmProtos::QuickWidgetInfo::QuickWidgetType.const_get(const)
       acc
     end
     
+    # Enum for window types
     WINDOW_ENUM_MAP = DesktopWmProtos::DesktopWindowInfo::DesktopWindowType.constants.inject({}) do |acc, const|
-      #puts const.inspect
       acc[const.to_s.downcase.to_sym] = DesktopWmProtos::DesktopWindowInfo::DesktopWindowType.const_get(const)
       acc
     end
     
+    # Enum for search types
     WIDGET_SEARCHTYPE_ENUM_MAP = DesktopWmProtos::QuickWidgetSearch::QuickWidgetSearchType.constants.inject({}) do |acc, const|
       acc[const.to_s.downcase.to_sym] = DesktopWmProtos::QuickWidgetSearch::QuickWidgetSearchType.const_get(const)
       acc
     end
 
+    # Enum for drop position types for dropping a widget onto another
     DROPPOSITION_ENUM_MAP = QuickWidget::DropPosition.constants.inject({}) do |acc, const|
-      #puts const.inspect
       acc[const.to_s.downcase.to_sym] = QuickWidget::DropPosition.const_get(const)
       acc
     end 

data/lib/operawatir/desktop_helper.rb

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+
+# TODO
+#   You need to set the OPERA_LAUNCHER and OPERA_PATH environment variables
+#   for this Helper to work.
+
+require 'operawatir'
+require 'rspec'
+require 'rbconfig'
+
+module OperaWatir::DesktopHelper
+  extend self
+  
+  def settings
+    OperaWatir::DesktopBrowser.settings
+  end
+  
+  def browser
+    @browser ||= OperaWatir::DesktopBrowser.new
+  end
+  
+  def configure_rspec!
+    RSpec.configure do |config|
+      
+      # Set every RSpec option
+      settings.each do |key, value|
+        config.send("#{key}=", value) if config.respond_to?("#{key}=")
+        if key.to_s.eql?("files_to_run")
+          @@files = value
+        end
+      end
+            
+      config.include SpecHelpers
+      
+      config.before(:all) {
+        if OperaWatir::DesktopHelper::settings[:no_restart] == false
+          unless @@files.empty?
+            path = File.join(Dir.getwd, @@files.shift)
+            filepath = path.chomp(".rb")
+            browser.reset_prefs(filepath)
+          end
+        else
+          # Must create browser object here so that none of the
+          # test is run before Opera has been launched
+          browser
+        end
+      }
+
+      config.after(:suite) { 
+        # Use the @browser directly because we don't want
+        # to launch Opera here if it's not running
+        if @browser
+
+          if settings[:no_quit] == false
+            # Shutdown Opera
+            @browser.quit_opera
+            @browser.delete_profile
+          end
+
+          # Shutdown the driver
+          @browser.quit_driver
+        end
+      }
+    end
+  end
+
+  def run!(settings={})
+    OperaWatir::DesktopBrowser.settings = settings
+    configure_rspec!
+    RSpec::Core::Runner.autorun
+  end
+  
+private
+
+  module SpecHelpers
+    def browser
+      OperaWatir::DesktopHelper.browser
+    end
+
+    def window
+      browser.active_window
+    end
+  end
+end

data/lib/operawatir/element.rb

@@ -68,10 +68,22 @@ class OperaWatir::Element
 
   alias_method :to_s, :text
 
-  def_delegator :node, :getValue, :value
   def_delegator :node, :getElementName, :tag_name
   def_delegator :node, :clear, :clear
 
+  # On elements of type `input`, `textarea` or `select` it will fetch
+  # the texteditable `value` attribute, on every other element type it
+  # returns the DOM attribute `value`.
+  #
+  # @return [String] Value of the element.
+  def value
+    if tag_name =~ /input|textarea|select/i
+      node.getValue
+    else
+      attr :value
+    end
+  end
+
   def disabled?
     !enabled?
   end
@@ -91,7 +103,7 @@ class OperaWatir::Element
 
   # Events
 
-  def click!(x=0, y=0)
+  def click(x=0, y=0)
     node.click(x.to_i, y.to_i)
   end
 
@@ -127,17 +139,18 @@ class OperaWatir::Element
 
   def text=(string)
     # Focus before typing
-    node.click
+    clear unless value.empty?
     node.sendKeys(string.split('').to_java(:string))
   end
 
   alias_method :set, :text=
+  alias_method :value=, :text=
 
   def send_keys(*list)
     raise Exceptions::NotImplementedException
   end
 
-  def trigger!(event, x = 0, y = 0)
+  def fire_event(event, x = 0, y = 0)
     loc = location
     x += loc[:x]
     y += loc[:y]
@@ -225,4 +238,10 @@ private
     end
   end
 
+  def find_elements_by_name(value)
+    node.findElementsByName(value).to_a.map do |n|
+      OperaWatir::Element.new(n)
+    end
+  end
+
 end

data/lib/operawatir/exceptions.rb

@@ -37,5 +37,8 @@ module OperaWatir::Exceptions
 
   # Raised when pressing a modifier key that doesn't exist.
   class InvalidKeyException < OperaWatirException; end
+
+  # Raised when an exception occurs in Preferences.
+  class PreferencesException < OperaWatirException; end
   
 end

data/lib/operawatir/helper.rb

@@ -29,7 +29,10 @@ module OperaWatir::Helper
             
       config.include SpecHelpers
       
-      config.after(:suite) { browser.quit! if browser }
+      config.after(:suite) do
+        browser.quit if browser
+        exit
+      end
     end
   end
 

data/lib/operawatir/platform.rb

@@ -1,36 +1,6 @@
 require 'rbconfig'
 
 class OperaWatir::Platform
-  def self.launcher
-    return ENV['OPERA_LAUNCHER'] if ENV['OPERA_LAUNCHER']
-
-    path = case os
-    when :windows
-      raise Exceptions::NotImplementedException, 'only 32-bit windows supported' if bitsize == 64
-      'utils/launchers/launcher-win32-i86pc.exe'
-    when :linux
-      postfix = bitsize == 64 ? 'x86_64' : 'i686'
-      "utils/launchers/launcher-linux-#{postfix}"
-    when :macosx
-      'utils/launchers/launcher-mac'
-    end
-
-    if path
-      File.join(root, path)
-    else
-      raise Exceptions::NotImplementedException, "no known launcher for #{os.inspect}, set OPERA_LAUNCHER to override"
-    end
-
-  end
-
-  def self.opera
-    ENV['OPERA_PATH']
-  end
-
-  def self.args
-    ENV['OPERA_ARGS'] || ''
-  end
-
   def self.os
     @os ||= (
       host_os = RbConfig::CONFIG['host_os']
@@ -48,12 +18,4 @@ class OperaWatir::Platform
       end
     )
   end
-
-  def self.bitsize
-    ENV_JAVA['sun.arch.data.model'].to_i
-  end
-
-  def self.root
-    @root ||= File.expand_path('../../..', __FILE__)
-  end
 end