firewatir 1.6.2 → 1.6.5

data/lib/firewatir/elements/not_used.rb

@@ -0,0 +1,278 @@
+# # this class is a collection of the table body objects that exist in the table
+# # it wouldnt normally be created by a user, but gets returned by the bodies method of the Table object
+# # many of the methods available to this object are inherited from the Element class
+# # TODO: Implement TableBodies class.
+# class TableBodies < Element
+# 
+#   # Description:
+#   #   Initializes the form element.
+#   #
+#   # Input:
+#   #   - how - Attribute to identify the form element.
+#   #   - what - Value of that attribute.
+#   #
+#   def initialize( parent_table)
+#     element = container
+#     @o = parent_table     # in this case, @o is the parent table
+#   end
+# 
+#   # returns the number of TableBodies that exist in the table
+#   def length
+#     assert_exists
+#     return @o.tBodies.length
+#   end
+# 
+#   # returns the n'th Body as a FireWatir TableBody object
+#   def []n
+#     assert_exists
+#     return TableBody.new(element, :direct, ole_table_body_at_index(n))
+#   end
+# 
+#   # returns an ole table body
+#   def ole_table_body_at_index(n)
+#     return @o.tBodies[(n-1).to_s]
+#   end
+# 
+#   # iterates through each of the TableBodies in the Table. Yields a TableBody object
+#   def each
+#     1.upto( @o.tBodies.length ) { |i| yield TableBody.new(element, :direct, ole_table_body_at_index(i)) }
+#   end
+# 
+# end # TableBodies
+# 
+# # this class is a table body
+# # TODO: Implement TableBody class
+# class TableBody < Element
+#   def locate
+#     @o = nil
+#     if @how == :direct
+#       @o = @what     # in this case, @o is the table body
+#     elsif @how == :index
+#       @o = @parent_table.bodies.ole_table_body_at_index(@what)
+#     end
+#     @rows = []
+#     if @o
+#       @o.rows.each do |oo|
+#         @rows << TableRow.new(element, :direct, oo)
+#       end
+#     end
+#   end
+# 
+# 
+#   # Description:
+#   #   Initializes the form element.
+#   #
+#   # Input:
+#   #   - how - Attribute to identify the form element.
+#   #   - what - Value of that attribute.
+#   #
+#   def initialize( how, what, parent_table = nil)
+#     element = container
+#     @how = how
+#     @what = what
+#     @parent_table = parent_table
+#     super nil
+#   end
+# 
+#   # returns the specified row as a TableRow object
+#   def [](n)
+#     assert_exists
+#     return @rows[n - 1]
+#   end
+# 
+#   # iterates through all the rows in the table body
+#   def each
+#     locate
+#     0.upto(@rows.length - 1) { |i| yield @rows[i] }
+#   end
+# 
+#   # returns the number of rows in this table body.
+#   def length
+#     return @rows.length
+#   end
+# end # TableBody
+
+# # this class is the super class for the iterator classes ( buttons, links, spans etc
+# # it would normally only be accessed by the iterator methods ( spans , links etc) of IE
+# class ElementCollections
+#   include Enumerable
+#   include Container
+# 
+#   # Super class for all the iteractor classes
+#   #   * container  - an instance of an IE object
+#   def initialize( container)
+#     element = container
+#     @length = length() # defined by subclasses
+# 
+#     # set up the items we want to display when the show method s used
+#     set_show_items
+#   end
+# 
+#   private
+#   def set_show_items
+#     @show_attributes = AttributeLengthPairs.new( "id" , 20)
+#     @show_attributes.add( "name" , 20)
+#   end
+# 
+#   public
+#   def get_length_of_input_objects(object_type)
+#     object_types =
+#     if object_type.kind_of? Array
+#       object_type
+#     else
+#       [ object_type ]
+#     end
+# 
+#     length = 0
+#     objects = element.document.getElementsByTagName("INPUT")
+#     if  objects.length > 0
+#       objects.each do |o|
+#         length += 1 if object_types.include?(o.invoke("type").downcase )
+#       end
+#     end
+#     return length
+#   end
+# 
+#   # iterate through each of the elements in the collection in turn
+#   def each
+#     0.upto( @length-1 ) { |i | yield iterator_object(i) }
+#   end
+# 
+#   # allows access to a specific item in the collection
+#   def [](n)
+#     return iterator_object(n-1)
+#   end
+# 
+#   # this method is the way to show the objects, normally used from irb
+#   def show
+#     s="index".ljust(6)
+#     @show_attributes.each do |attribute_length_pair|
+#       s=s + attribute_length_pair.attribute.ljust(attribute_length_pair.length)
+#     end
+# 
+#     index = 1
+#     self.each do |o|
+#       s= s+"\n"
+#       s=s + index.to_s.ljust(6)
+#       @show_attributes.each do |attribute_length_pair|
+#         begin
+#           s=s  + eval( 'o.getOLEObject.invoke("#{attribute_length_pair.attribute}")').to_s.ljust( attribute_length_pair.length  )
+#         rescue=>e
+#           s=s+ " ".ljust( attribute_length_pair.length )
+#         end
+#       end
+#       index+=1
+#     end
+#     puts s
+#   end
+# 
+#   # this method creates an object of the correct type that the iterators use
+#   private
+#   def iterator_object(i)
+#     element_class.new(element, :index, i+1)
+#   end
+# end
+# 
+# # --
+# #   These classes are not for public consumption, so we switch off rdoc
+# #
+# # presumes element_class or element_tag is defined
+# # for subclasses of ElementCollections
+# module CommonCollection
+#   def element_tag
+#     element_class.tag
+#   end
+#   def length
+#     element.document.getElementsByTagName(element_tag).length
+#   end
+# end
+# 
+# # This class is used as part of the .show method of the iterators class
+# # it would not normally be used by a user
+# class AttributeLengthPairs
+# 
+#   # This class is used as part of the .show method of the iterators class
+#   # it would not normally be used by a user
+#   class AttributeLengthHolder
+#     attr_accessor :attribute
+#     attr_accessor :length
+# 
+#     def initialize( attrib, length)
+#       @attribute = attrib
+#       @length = length
+#     end
+#   end
+# 
+#   def initialize( attrib=nil , length=nil)
+#     @attr=[]
+#     add( attrib , length ) if attrib
+#     @index_counter=0
+#   end
+# 
+#   # BUG: Untested. (Null implementation passes all tests.)
+#   def add( attrib , length)
+#     @attr <<  AttributeLengthHolder.new( attrib , length )
+#   end
+# 
+#   def delete(attrib)
+#     item_to_delete=nil
+#     @attr.each_with_index do |e,i|
+#       item_to_delete = i if e.attribute==attrib
+#     end
+#     @attr.delete_at(item_to_delete ) unless item_to_delete == nil
+#   end
+# 
+#   def next
+#     temp = @attr[@index_counter]
+#     @index_counter +=1
+#     return temp
+#   end
+# 
+#   def each
+#     0.upto( @attr.length-1 ) { |i | yield @attr[i]   }
+#   end
+# end
+# 
+
+#   
+# 
+# # Module for handling the Javascript pop-ups. Not in use currently, will be available in future.
+# # Use ff.startClicker() method for clicking javascript pop ups. Refer to unit tests on how to handle
+# # javascript pop up (unittests/javascript_test.rb)
+# module Dialog
+#   # Class for handling javascript popup. Not in use currently, will be available in future. See unit tests on how to handle
+#   # javascript pop up (unittests/javascript_test.rb).
+#   class JSPopUp
+#     include Container
+# 
+#     def has_appeared(text)
+#       require 'socket'
+#       sleep 4
+#       shell = TCPSocket.new("localhost", 9997)
+#       read_socket(shell)
+#       #jssh_command =  "var url = document.URL;"
+#       jssh_command = "var length = getWindows().length; var win;length;\n"
+#       #jssh_command << "for(var i = 0; i < length; i++)"
+#       #jssh_command << "{"
+#       #jssh_command << "   win = getWindows()[i];"
+#       #jssh_command << "   if(win.opener != null && "
+#       #jssh_command << "      win.title == \"[JavaScript Application]\" &&"
+#       #jssh_command << "      win.opener.document.URL == url)"
+#       #jssh_command << "   {"
+#       #jssh_command << "       break;"
+#       #jssh_command << "   }"
+#       #jssh_command << "}"
+# 
+#       #jssh_command << " win.title;\n";
+#       #jssh_command << "var dialog = win.document.childNodes[0];"
+#       #jssh_command << "vbox = dialog.childNodes[1].childNodes[1];"
+#       #jssh_command << "vbox.childNodes[1].childNodes[0].childNodes[0].textContent;\n"
+#       puts jssh_command
+#       shell.send("#{jssh_command}", 0)
+#       jstext = read_socket(shell)
+#       puts jstext
+#       return jstext == text
+#     end
+#   end # JSPopUp
+# end # Dialog
+# 

data/lib/firewatir/elements/option.rb

@@ -0,0 +1,131 @@
+module FireWatir
+  #
+  # Description:
+  #   Class for Option element.
+  #
+  class Option < InputElement
+    #
+    # Description:
+    #   Initializes the instance of option object.
+    #
+    # Input:
+    #   - select_list - instance of select list element.
+    #   - attribute - Attribute to identify the option.
+    #   - value - Value of that attribute.
+    #
+    def initialize (select_list, attribute, value)
+      @select_list = @container = select_list
+      @how = attribute
+      @what = value
+      @option = nil
+      @element_name = ""
+      
+      unless [:text, :value, :jssh_name].include? attribute 
+        raise MissingWayOfFindingObjectException,
+                "Option does not support attribute #{@how}"
+      end
+      #puts @select_list.o.length
+      #puts "what is : #{@what}, how is #{@how}, list name is : #{@select_list.element_name}"
+      if(attribute == :jssh_name)
+        @element_name = @what
+        @option = self
+      else    
+        @select_list.o.each do |option| # items in the list
+          #puts "option is : #{option}"
+          if(attribute == :value)
+            match_value = option.value
+          else    
+            match_value = option.text
+          end    
+          #puts "value is #{match_value}"
+          if value.matches( match_value) #option.invoke(attribute))
+            @option = option
+            @element_name = option.element_name
+            break
+          end
+        end
+      end    
+    end
+    
+    #
+    # Description:
+    #   Checks if option exists or not.
+    #
+    def assert_exists
+      unless @option
+        raise UnknownObjectException,  
+                "Unable to locate an option using #{@how} and #{@what}"
+      end
+    end
+    private :assert_exists
+    
+    #
+    # Description:
+    #   Selects the option.
+    #
+    def select
+      assert_exists
+      if(@how == :text)
+        @select_list.select(@what)
+      elsif(@how == :value)
+        @select_list.select_value(@what)
+      end    
+    end
+    
+    #
+    # Description:
+    #   Gets the class name of the option.
+    #
+    # Output:
+    #   Class name of the option.
+    #
+    def class_name
+      assert_exists
+      jssh_socket.send("#{element_object}.className;\n", 0)
+      return read_socket()
+    end
+    
+    #
+    # Description:
+    #   Gets the text of the option.
+    #
+    # Output:
+    #   Text of the option.
+    #
+    def text
+      assert_exists
+      jssh_socket.send("#{element_object}.text;\n", 0)
+      return read_socket()
+    end
+    
+    #
+    # Description:
+    #   Gets the value of the option.
+    #
+    # Output:
+    #   Value of the option.
+    #
+    def value
+      assert_exists
+      jssh_socket.send("#{element_object}.value;\n", 0)
+      return read_socket()
+    end
+    
+    #
+    # Description:
+    #   Gets the status of the option; whether it is selected or not.
+    #
+    # Output:
+    #   True if option is selected, false otherwise.
+    #
+    def selected
+      assert_exists
+      jssh_socket.send("#{element_object}.selected;\n", 0)
+      value = read_socket()
+      return true if value == "true"
+      return false if value == "false"
+    end
+    
+    
+  end # Option
+end # FireWatir

data/lib/firewatir/elements/radio_check_common.rb

@@ -0,0 +1,163 @@
+module FireWatir
+  #
+  # Description:
+  #   Base class for checkbox and radio button elements.
+  #
+  class RadioCheckCommon < Element
+    attr_accessor :element_name
+    #
+    # Description:
+    #   Initializes the instance of element object. Element can be checkbox or radio button.
+    #
+    # Input:
+    #   - how - Attribute to identify the element.
+    #   - what - Value of that attribute.
+    #   - value - value of the element.
+    #
+    def initialize(container, how, what, value = nil)
+      @how = how
+      @what = what
+      @value = value
+      @container = container
+    end
+
+    #
+    # Description:
+    #   Locate the element on the page. Element can be a checkbox or radio button.
+    #
+    def locate
+      case @how
+      when :jssh_name
+        @element_name = @what
+      when :xpath
+        @element_name = element_by_xpath(@container, @what)
+      else
+        @element_name = locate_tagged_element("input", @how, @what, @type, @value)
+      end
+      @o = self
+    end
+
+    #
+    # Description:
+    #   Checks if element i.e. radio button or check box is checked or not.
+    #
+    # Output:
+    #   True if element is checked, false otherwise.
+    #
+    def set?
+      assert_exists
+      return @o.checked
+    end
+    alias getState set?
+    alias checked? set?
+    alias isSet?   set?
+
+    #
+    # Description:
+    #   Unchecks the radio button or check box element.
+    #   Raises ObjectDisabledException exception if element is disabled.
+    #
+    def clear
+      assert_exists
+      assert_enabled
+      #highlight(:set)
+      set_clear_item(false)
+      #highlight(:clear)
+    end
+
+    #
+    # Description:
+    #   Checks the radio button or check box element.
+    #   Raises ObjectDisabledException exception if element is disabled.
+    #
+    def set
+      assert_exists
+      assert_enabled
+      #highlight(:set)
+      set_clear_item(true)
+      #highlight(:clear)
+    end
+
+    #
+    # Description:
+    #   Used by clear and set method to uncheck and check radio button and checkbox element respectively.
+    #
+    def set_clear_item(set)
+      @o.fire_event("onclick")
+      @container.wait
+    end
+    private :set_clear_item
+
+  end # RadioCheckCommon
+
+  #
+  # Description:
+  #   Class for RadioButton element.
+  #
+  class Radio < RadioCheckCommon
+    def initialize *args
+      super
+      @type = ["radio"]
+    end
+
+    def clear
+      assert_exists
+      assert_enabled
+      #higlight(:set)
+      @o.checked = false
+      #highlight(:clear)
+    end
+
+  end # Radio
+
+  #
+  # Description:
+  # Class for Checkbox element.
+  #
+  class CheckBox < RadioCheckCommon
+    def initialize *args
+      super
+      @type = ["checkbox"]
+    end
+
+    #
+    # Description:
+    #   Checks or unchecks the checkbox. If no value is supplied it will check the checkbox.
+    #   Raises ObjectDisabledException exception if the object is disabled
+    #
+    # Input:
+    #   - set_or_clear - Parameter indicated whether to check or uncheck the checkbox.
+    #                    True to check the check box, false for unchecking the checkbox.
+    #
+    def set( set_or_clear=true )
+      assert_exists
+      assert_enabled
+      highlight(:set)
+
+      if set_or_clear == true
+        if @o.checked == false
+          set_clear_item( true )
+        end
+      else
+        self.clear
+      end
+      highlight(:clear )
+    end
+
+    #
+    # Description:
+    #   Unchecks the checkbox.
+    #   Raises ObjectDisabledException exception if the object is disabled
+    #
+    def clear
+      assert_exists
+      assert_enabled
+      highlight( :set)
+      if @o.checked == true
+        set_clear_item( false )
+      end
+      highlight( :clear)
+    end
+
+  end # CheckBox
+end # FireWatir