watir-webdriver 0.0.6 → 0.0.7

data/Rakefile

@@ -14,10 +14,12 @@ begin
     gem.add_dependency "selenium-webdriver", '>= 0.0.26'
 
     gem.add_development_dependency "rspec"
-    gem.add_development_dependency "webidl"
+    gem.add_development_dependency "webidl", ">= 0.0.4"
     gem.add_development_dependency "sinatra", ">= 1.0"
+    gem.add_development_dependency "nokogiri"
     gem.add_development_dependency "activesupport", ">= 2.3.5" # for pluralization during code generation
   end
+
   Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
@@ -38,57 +40,77 @@ end
 
 task :spec => :check_dependencies
 
+task :lib do
+  $LOAD_PATH.unshift(File.expand_path("lib", File.dirname(__FILE__)))
+end
+
 namespace :html5 do
-  IDL_PATH    = "support/html5/html5.idl"
-  SPEC_URI    = "http://dev.w3.org/html5/spec/Overview.html" # TODO: use http://www.whatwg.org/specs/web-apps/current-work/source
+  SPEC_URI  = "http://www.whatwg.org/specs/web-apps/current-work/"
+  SPEC_PATH = "support/html5.html"
 
-  desc "Print IDL parts from #{SPEC_URI}"
-  task :extract do
-    require "nokogiri"
+  task :html_lib => :lib do
+    require 'watir-webdriver/html'
+  end
+
+  desc "Download the HTML5 spec from #{SPEC_URI}"
+  task :download do
     require "open-uri"
-    doc = Nokogiri.HTML(open(SPEC_URI))
-    puts doc.search("//pre[@class='idl']").map {  |e| e.inner_text }.join("\n\n")
+    mv SPEC_PATH, "#{SPEC_PATH}.old" if File.exist?(SPEC_PATH)
+    downloaded_bytes = 0
+
+    File.open(SPEC_PATH, "w") do |io|
+      io << "<!--  downloaded from #{SPEC_URI} on #{Time.now} -->\n"
+      io << data = open(SPEC_URI).read
+      downloaded_bytes = data.bytesize
+    end
+
+    puts "#{SPEC_URI} => #{SPEC_PATH} (#{downloaded_bytes} bytes)"
   end
 
-  desc 'Re-enerate the base Watir element classes from the spec '
-  task :generate do
-    require "support/html5/watir_visitor"
+  desc "Print IDL parts from #{SPEC_URI}"
+  task :print => :html_lib do
+    extractor = Watir::HTML::SpecExtractor.new(SPEC_PATH)
 
-    code = WatirVisitor.generate_from(IDL_PATH)
-    old_file = "lib/watir-webdriver/elements/generated.rb"
+    extractor.process.each do |tag_name, interface_definitions|
+      puts "#{tag_name.ljust(10)} => #{interface_definitions.map { |e| e.name }}"
+    end
 
-    File.open("#{old_file}.new", "w") { |file| file << code }
-    if File.exist?(old_file)
-      system "diff -Naut #{old_file} #{old_file}.new | less"
+    extractor.print_hierarchy
+
+    unless extractor.errors.empty?
+      puts "\n\n<======================= ERRORS =======================>\n\n"
+      puts extractor.errors.join("\n" + "="*80 + "\n")
     end
   end
 
-  desc 'Check the syntax of support/html5/*.idl'
-  task :syntax do
-    require 'webidl'
-    parser = WebIDL::Parser::IDLParser.new
-    failures = []
-    Dir['support/html5/*.idl'].each do |path|
-      unless parser.parse(File.read(path))
-        failures << [path, parser.failure_reason]
-      end
+  desc 'Re-enerate the base Watir element classes from the spec '
+  task :generate => :html_lib do
+    old_file = "lib/watir-webdriver/elements/generated.rb"
+    generator = Watir::HTML::Generator.new
+
+    File.open("#{old_file}.new", "w") do |file|
+      generator.generate(SPEC_PATH, file)
     end
 
-    if failures.any?
-      puts "Parse errors!"
-      failures.each { |path, reason| puts "#{path.ljust(40)}: #{reason}"  }
-    else
-      puts "Syntax OK."
+    if File.exist?(old_file)
+      system "diff -Naut #{old_file} #{old_file}.new | less"
     end
   end
 
+  desc 'Move generated.rb.new to generated.rb'
+  task :overwrite do
+    file = "lib/watir-webdriver/elements/generated.rb"
+    mv "#{file}.new", file
+  end
+
 end # html5
 
 task :default => :spec
 
 begin
   require 'yard'
-  require 'support/yard_handlers'
+  Rake::Task[:lib].invoke
+  require "yard/handlers/watir"
   YARD::Rake::YardocTask.new do |task|
     task.options = %w[--debug] # this is pretty slow, so nice with some output
   end

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.7

data/lib/watir-webdriver.rb

@@ -21,35 +21,33 @@ module Watir
     end
 
     def element_class_for(tag_name)
-      tag_to_class[tag_name] || HTMLElement
+      tag_to_class[tag_name.to_sym] || HTMLElement
     end
   end
 
 end
 
-require "watir-webdriver/base_element"
+require "watir-webdriver/attribute_helper"
+require "watir-webdriver/element"
 require "watir-webdriver/collections/element_collection"
 require "watir-webdriver/elements/generated"
 require "watir-webdriver/elements/frame"
 require "watir-webdriver/elements/input"
 require "watir-webdriver/elements/button"
-require "watir-webdriver/collections/buttons_collection"
 require "watir-webdriver/elements/checkbox"
 require "watir-webdriver/elements/file_field"
-require "watir-webdriver/elements/font"
-require "watir-webdriver/elements/headings"
 require "watir-webdriver/elements/image"
 require "watir-webdriver/elements/link"
+require "watir-webdriver/elements/font"
 require "watir-webdriver/elements/radio"
 require "watir-webdriver/elements/text_field"
-require "watir-webdriver/collections/text_fields_collection"
 require "watir-webdriver/elements/hidden"
-require "watir-webdriver/elements/select_list"
+require "watir-webdriver/elements/select"
 require "watir-webdriver/elements/form"
 require "watir-webdriver/elements/option"
 require "watir-webdriver/elements/table"
 require "watir-webdriver/elements/table_row"
-require "watir-webdriver/collections/table_rows_collection"
+require "watir-webdriver/collections/table_row_collection"
 
 Watir.tag_to_class.freeze
 

data/lib/watir-webdriver/attribute_helper.rb

@@ -0,0 +1,121 @@
+module Watir
+  
+  #
+  # @private
+  # 
+  # Extended by Element, provides methods for defining attributes on the element classes.
+  # 
+  
+  module AttributeHelper
+    
+    IGNORED_ATTRIBUTES = [:text, :hash]
+    
+    def typed_attributes
+      @typed_attributes ||= Hash.new { |hash, type| hash[type] = []  }
+    end
+
+    def attribute_list
+      @attribute_list ||= (
+        list = typed_attributes.values.flatten
+        list += ancestors[1..-1].map do |e|
+          e.attribute_list if e.respond_to?(:attribute_list)
+        end.compact.flatten
+      ).uniq
+    end
+
+    def attributes(attribute_map = nil)
+      attribute_map or return attribute_list
+
+      add_attributes attribute_map
+
+      attribute_map.each do |type, attribs|
+        attribs.each do |name|
+          # we don't want to override methods like :text or :hash
+          next if IGNORED_ATTRIBUTES.include?(name)
+          define_attribute(type, name)
+        end
+      end
+    end
+
+    private
+
+    def define_attribute(type, name)
+      method_name    = method_name_for(type, name)
+      attribute_name = attribute_for_method(name)
+
+      (@attributes ||= []) << attribute_name
+
+      case type
+      when :string
+        define_string_attribute(method_name, attribute_name)
+      when :bool
+        define_boolean_attribute(method_name, attribute_name)
+      when :int
+        define_int_attribute(method_name, attribute_name)
+      else
+        # $stderr.puts "treating #{type.inspect} as string for now"
+      end
+    end
+
+    def define_string_attribute(mname, aname)
+      define_method mname do
+        assert_exists
+        @element.attribute(aname).to_s
+      end
+    end
+
+    def define_boolean_attribute(mname, aname)
+      define_method mname do
+        assert_exists
+        !!@element.attribute(aname)
+      end
+    end
+
+    def define_int_attribute(mname, aname)
+      define_method mname do
+        assert_exists
+        @element.attribute(aname).to_i
+      end
+    end
+
+    def add_attributes(attributes)
+      attributes.each do |type, attr_list|
+        typed_attributes[type] += attr_list
+      end
+    end
+
+    def method_name_for(type, attribute)
+      # TODO: rethink this - this list could get pretty long...
+      name = case attribute
+             when :html_for
+               'for'
+             when :col_span
+               'colspan'
+             when :row_span
+               'rowspan'
+             else
+               attribute.to_s
+             end
+
+      name << "?" if type == :bool
+
+      name
+    end
+
+    def attribute_for_method(method)
+      case method.to_sym
+      when :class_name
+        'class'
+      when :html_for
+        'for'
+      when :read_only
+        'readonly'
+      when :http_equiv
+        'http-equiv'
+      else
+        method.to_s
+      end
+    end
+    
+  end # AttributeHelper
+end # Watir

data/lib/watir-webdriver/browser.rb

@@ -4,7 +4,7 @@ module Watir
     include Container
 
     attr_reader :driver
-    alias_method :wd, :driver # ensures duck typing with BaseElement
+    alias_method :wd, :driver # ensures duck typing with Watir::Element
 
     class << self
       def start(url, browser = :firefox)
@@ -34,6 +34,7 @@ module Watir
 
       @error_checkers = []
       @current_frame  = nil
+      @closed         = false
     end
 
     def inspect
@@ -73,7 +74,9 @@ module Watir
     end
 
     def close
+      return if @closed
       @driver.quit
+      @closed = true
     end
     alias_method :quit, :close # TODO: close vs quit
 
@@ -99,7 +102,7 @@ module Watir
     end
 
     def execute_script(script, *args)
-      args.map! { |e| e.kind_of?(Watir::BaseElement) ? e.element : e }
+      args.map! { |e| e.kind_of?(Watir::Element) ? e.element : e }
       returned = @driver.execute_script(script, *args)
 
       if returned.kind_of? WebDriver::Element
@@ -128,18 +131,22 @@ module Watir
     end
 
     #
-    # Protocol shared with BaseElement
+    # Protocol shared with Watir::Element
     #
     # @api private
     #
 
     def assert_exists
-      driver.switch_to.default_content
-      true
+      if @closed
+        raise Error, "browser was closed"
+      else
+        driver.switch_to.default_content
+        true
+      end
     end
 
     def exist?
-      true
+      not @closed
     end
 
     def browser

data/lib/watir-webdriver/collections/element_collection.rb

@@ -3,12 +3,13 @@ module Watir
   class ElementCollection
     include Enumerable
 
-    def initialize(parent, element_class)
-      @parent, @element_class = parent, element_class
+    def initialize(parent, selector)
+      @parent   = parent
+      @selector = selector
     end
 
     #
-    # @yieldparam [Watir::BaseElement] element Iterate through the elements in this collection.
+    # @yieldparam [Watir::Element] element Iterate through the elements in this collection.
     #
 
     def each(&blk)
@@ -32,54 +33,59 @@ module Watir
     # instance even if the index is out of bounds.
     #
     # @param [Fixnum] n Index of wanted element, 0-indexed
-    # @return [Watir::BaseElement] Returns an instance of a Watir::BaseElement subclass
+    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
     #
 
 
     def [](idx)
-      to_a[idx] || @element_class.new(@parent, :index, idx)
+      to_a[idx] || element_class.new(@parent, :index => idx)
     end
 
     #
     # First element of this collection
     #
-    # @return [Watir::BaseElement] Returns an instance of a Watir::BaseElement subclass
+    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
     #
 
     def first
-      to_a[0] || @element_class.new(@parent, :index, 0)
+      to_a[0] || element_class.new(@parent, :index => 0)
     end
 
     #
     # Last element of the collection
     #
-    # @return [Watir::BaseElement] Returns an instance of a Watir::BaseElement subclass
+    # @return [Watir::Element] Returns an instance of a Watir::Element subclass
     #
 
     def last
-      to_a[-1] || @element_class.new(@parent, :index, -1)
+      to_a[-1] || element_class.new(@parent, :index => -1)
     end
 
     #
     # This collection as an Array
     #
-    # @return [Array<Watir::BaseElement>]
+    # @return [Array<Watir::Element>]
     #
 
     def to_a
-      # TODO: optimize - lazily @element_class instance
-      @to_a ||= elements.map { |e| @element_class.new(@parent, :element, e) }
+      # TODO: optimize - lazy element_class instance?
+      @to_a ||= elements.map { |e| element_class.new(@parent, :element => e) }
     end
 
     private
 
     def elements
-      @elements ||= ElementLocator.new(
+      @elements ||= locator_class.new(
         @parent.wd,
-        @element_class.default_selector,
-        @element_class.attribute_list
+        @selector,
+        element_class.attribute_list
       ).locate_all
     end
 
+    # overridable by subclasses
+    def locator_class
+      ElementLocator
+    end
+
   end # ElementCollection
 end # Watir

data/lib/watir-webdriver/collections/table_row_collection.rb

@@ -0,0 +1,11 @@
+module Watir
+  class TableRowCollection < ElementCollection
+
+    private
+
+    def locator_class
+      @parent.kind_of?(Watir::Table) ? TableRowLocator : super
+    end
+
+  end # TrCollection
+end # Watir