watir-webdriver 0.0.6 → 0.0.7

data/lib/watir-webdriver/elements/hidden.rb

@@ -1,13 +1,24 @@
 # encoding: utf-8
 module Watir
   class Hidden < Input
-    identifier :type => 'hidden'
-
-    container_method  :hidden
-    collection_method :hiddens
-
     def visible?
       false
     end
   end
+
+  module Container
+    def hidden(*args)
+      Hidden.new(self, extract_selector(args).merge(:tag_name => "input", :type => "hidden"))
+    end
+
+    def hiddens(*args)
+      HiddenCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "hidden"))
+    end
+  end # Container
+
+  class HiddenCollection < InputCollection
+    def element_class
+      Hidden
+    end
+  end # HiddenCollection
 end

data/lib/watir-webdriver/elements/input.rb

@@ -4,6 +4,20 @@ module Watir
 
     alias_method :readonly?, :read_only?
 
+    #
+    # @private
+    #
+    # subclasses can use this to validate the incoming element
+    #
+
+    def self.from(parent, element)
+      unless element.tag_name == "input"
+        raise TypeError, "can't create #{self} from #{element.inspect}"
+      end
+
+      new(parent, :element => element)
+    end
+
     def enabled?
       !disabled?
     end
@@ -31,24 +45,49 @@ module Watir
     # 'cast' the returned Input instance to one of the subclasses
     #
 
+    #
+    # @return [Watir::CheckBox]
+    # 
+
     def to_checkbox
       assert_exists
-      Watir::CheckBox.new(@parent, :element, @element)
+      CheckBox.from(@parent, @element)
     end
 
+    #
+    # @return [Watir::Radio]
+    # 
+    
     def to_radio
       assert_exists
-      Watir::Radio.new(@parent, :element, @element)
+      Radio.from(@parent, @element)
     end
 
+    #
+    # @return [Watir::Button]
+    # 
+    
     def to_button
       assert_exists
-      Watir::Button.new(@parent, :element, @element)
+      Button.from(@parent, @element)
+    end
+    
+    #
+    # @return [Watir::TextField]
+    # 
+
+    def to_text_field
+      assert_exists
+      TextField.from(@parent, @element)
     end
 
-    def to_select_list
+    #
+    # @return [Watir::FileField]
+    # 
+
+    def to_file_field
       assert_exists
-      Watir::SelectList.new(@parent, :element, @element)
+      FileField.from(@parent, @element)
     end
 
   end # Input

data/lib/watir-webdriver/elements/link.rb

@@ -1,13 +1,11 @@
 # encoding: utf-8
 module Watir
-  class Link < Anchor
-    default_selector.clear
-
-    identifier        :tag_name => 'a'
-    container_method  :link
-    collection_method :links
-
+  class Anchor
     alias_method :url, :href # deprecate?
+  end # Anchor
 
-  end # Link
+  module Container
+    alias_method :link,  :a
+    alias_method :links, :as
+  end
 end # Watir

data/lib/watir-webdriver/elements/radio.rb

@@ -1,11 +1,13 @@
 # encoding: utf-8
 module Watir
   class Radio < Input
-    identifier :type => 'radio'
-
-    container_method  :radio
-    collection_method :radios
+    def self.from(parent, element)
+      if element.attribute(:type) != "radio"
+        raise TypeError, "expected type=radio for #{element.inspect}"
+      end
 
+      super
+    end
     #
     # Select this radio button.
     #
@@ -25,6 +27,23 @@ module Watir
       assert_exists
       @element.selected?
     end
+  end # Radio
+
+  module Container
+    def radio(*args)
+      Radio.new(self, extract_selector(args).merge(:tag_name => "input", :type => "radio"))
+    end
 
-  end
-end
+    def radios(*args)
+      RadioCollection.new(self, extract_selector(args).merge(:tag_name => "input", :type => "radio" ))
+    end
+  end # Container
+
+  class RadioCollection < InputCollection
+    private
+
+    def element_class
+      Radio
+    end
+  end # RadioCollection
+end # Watir

data/lib/watir-webdriver/elements/{select_list.rb → select.rb}

@@ -1,11 +1,8 @@
 # encoding: utf-8
 module Watir
-  class SelectList < Select
+  class Select < HTMLElement
     include Watir::Exception
 
-    container_method  :select_list
-    collection_method :select_lists
-
     #
     # Returns true if this element is enabled
     #
@@ -59,7 +56,7 @@ module Watir
     #
 
     def select(str_or_rx)
-        select_by :text, str_or_rx, multiple?
+      select_by :text, str_or_rx, multiple?
     end
 
     #
@@ -103,9 +100,7 @@ module Watir
     #
 
     def value
-      o = options.find { |e| e.selected? }
-      return if o.nil?
-
+      o = options.find { |e| e.selected? } || return
       o.value
     end
 
@@ -215,6 +210,10 @@ module Watir
 
       ''
     end
+  end # Select
 
-  end # SelectList
+  module Container
+    alias_method :select_list,  :select
+    alias_method :select_lists, :selects
+  end # Container
 end # Watir

data/lib/watir-webdriver/elements/text_field.rb

@@ -4,13 +4,20 @@ module Watir
 
     attributes Watir::TextArea.typed_attributes
 
+    def self.from(parent, element)
+      type = element.attribute(:type)
+
+      if TextFieldLocator::NON_TEXT_TYPES.include?(type)
+        raise TypeError, "expected type != #{type} for #{element.inspect}"
+      end
+
+      super
+    end
+
     # hacky, but we want Input#type here, which was overriden by TextArea's attributes
     # so we're *overwriting* that method definition here
     def type; super; end
 
-    container_method  :text_field
-    collection_method :text_fields
-
     def inspect
       '#<%s:0x%x located=%s selector=%s>' % [self.class, hash*2, !!@element, selector_string]
     end
@@ -75,4 +82,26 @@ module Watir
       s
     end
   end
+
+  module Container
+    def text_field(*args)
+      TextField.new(self, extract_selector(args).merge(:tag_name => "input"))
+    end
+
+    def text_fields(*args)
+      TextFieldCollection.new(self, extract_selector(args).merge(:tag_name => "input"))
+    end
+  end # Container
+
+  class TextFieldCollection < InputCollection
+    private
+
+    def locator_class
+      TextFieldLocator
+    end
+
+    def element_class
+      TextField
+    end
+  end # TextFieldCollection
 end

data/lib/watir-webdriver/html.rb

@@ -0,0 +1,18 @@
+require "nokogiri"
+require "open-uri"
+require "pp"
+require "webidl"
+require "active_support/inflector"
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'body', 'bodys'
+  inflect.irregular 'tbody', 'tbodys'
+  inflect.irregular 'canvas', 'canvases'
+  inflect.irregular 'ins', 'inses'
+end
+
+require "watir-webdriver/html/util"
+require "watir-webdriver/html/visitor"
+require "watir-webdriver/html/idl_sorter"
+require "watir-webdriver/html/spec_extractor"
+require "watir-webdriver/html/generator"

data/lib/watir-webdriver/html/generator.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+module Watir
+  module HTML
+    class Generator
+
+      def generate(spec_url, io = StringIO.new)
+        @spec_url, @io = spec_url, io
+
+        extract_spec
+        cleanup_spec
+
+        write_header
+        write_class_defs
+        write_container_methods
+        write_footer
+
+        io
+      end
+
+      private
+
+      def generator
+        @generator ||= WebIDL::Generator.new(visitor)
+      end
+
+      def visitor
+        @visitor ||= Visitor.new
+      end
+
+      def extractor
+        @extractor ||= SpecExtractor.new(@spec_url)
+      end
+
+      def extract_spec
+        @tag2interfaces    = extractor.process
+        @sorted_interfaces = extractor.sorted_interfaces
+
+        if extractor.errors.any?
+          raise "error extracting spec: #{extractor.errors.join("\n")}"
+        end
+      end
+
+      def cleanup_spec
+        # ignore the link element for now
+        @tag2interfaces.delete("link")
+        @sorted_interfaces.reject! { |intf| intf.name == "HTMLLinkElement" }
+      end
+
+      def write_header
+        @io.puts "# Autogenerated from the HTML5 specification. Edits may be lost."
+        @io.puts "module Watir"
+      end
+
+      def write_class_defs
+        @sorted_interfaces.each do |interface|
+          @io.puts indent(generator.generate(interface))
+        end
+      end
+
+
+      def write_container_methods
+        @io.puts indent("module Container")
+
+        @tag2interfaces.sort.each do |tag, interfaces|
+          raise "multiple interfaces for tag #{tag.inspect}" unless interfaces.map { |e| e.name }.uniq.size == 1
+
+          tag_string       = tag.inspect
+          singular         = Util.paramify(tag)
+          plural           = singular.pluralize
+          element_class    = Util.classify(interfaces.first.name)
+          collection_class = "#{element_class}Collection"
+
+          # visitor.visit_tag(tag, interfaces.first.name) !?
+          @io.puts indent(<<-CODE, 3)
+#
+# @return [#{element_class}]
+#
+
+def #{singular}(*args)
+  #{element_class}.new(self, extract_selector(args).merge(:tag_name => #{tag_string}))
+end
+
+#
+# @return [#{collection_class}]
+#
+
+def #{plural}(*args)
+  #{collection_class}.new(self, extract_selector(args).merge(:tag_name => #{tag_string}))
+end
+
+Watir.tag_to_class[#{tag.to_sym.inspect}] = #{element_class}
+
+CODE
+        end
+
+        @io.puts indent("end # Container")
+      end
+
+      def write_footer
+        @io.puts "end # Watir"
+      end
+
+
+      def indent(code, indent = 1)
+        indent_string = " "*indent
+        code.split("\n").map { |line| indent_string + line }.join("\n")
+      end
+
+    end # Generator
+  end # HTML5
+end # Watir

data/lib/watir-webdriver/html/idl_sorter.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'tsort'
+
+module Watir
+  module HTML
+    class IDLSorter
+      include TSort
+
+      def initialize(interfaces)
+        @interfaces = {}
+
+        interfaces.each do |interface|
+          @interfaces[interface.name] ||= []
+          interface.inherits.each do |inherit|
+            (@interfaces[inherit.name] ||= []) << interface.name
+          end
+        end
+      end
+
+      def print
+        @visited = []
+        sort.each { |node| print_node(node) }
+      end
+
+      def sort
+        tsort.reverse
+      end
+
+      def tsort_each_node(&blk)
+        @interfaces.each_key(&blk)
+      end
+
+      def tsort_each_child(node, &blk)
+        @interfaces[node].each(&blk)
+      end
+
+      private
+
+      def print_node(node, indent = 0)
+        return if @visited.include?(node)
+        @visited << node
+        puts " "*indent + node
+        tsort_each_child(node) { |child| print_node(child, indent + 2)}
+      end
+
+    end # IDLSorter
+  end # HTML
+end # Watir