watir-webdriver 0.0.6 → 0.0.7

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

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+module Watir
+  module HTML
+    class SpecExtractor
+      def initialize(uri)
+        @uri = uri
+      end
+
+      def process
+        download_and_parse
+        extract_idl_parts
+        extract_interface_map
+        build_result
+      end
+
+      def errors
+        @errors ||= []
+      end
+
+      #
+      # returns a topoligically sorted array of WebIDL::Ast::Interface objects
+      #
+
+      def sorted_interfaces
+        process if @interfaces.nil?
+
+        sorter.sort.map { |name|
+          @interfaces_by_name[name] or puts "ignoring interface: #{name}"
+        }.flatten.compact
+      end
+
+      def print_hierarchy
+        process if @interfaces.nil?
+        sorter.print
+      end
+
+      private
+
+      def download_and_parse
+        open(@uri) { |io| @doc = Nokogiri.HTML(io) }
+      end
+
+      def extract_idl_parts
+        parsed = @doc.search("//pre[@class='idl']").map {  |e| parse_idl(e.inner_text) }.compact
+
+        @interfaces = parsed.map { |elements|
+          elements.select { |e| e.kind_of? WebIDL::Ast::Interface  }
+        }.flatten
+
+        @interfaces_by_name = @interfaces.group_by { |i| i.name }
+      end
+
+      def extract_interface_map
+        table = @doc.search("//h3[@id='elements-1']/following-sibling::table[1]").first
+        table or raise "could not find elements-1 table"
+
+        @interface_map = {}
+
+        parse_table(table).each do |row|
+          row['Element'].split(", ").each { |tag| @interface_map[tag] = row['Interface'] }
+        end
+      end
+
+      def build_result
+        # tag name => Interface instance(s)
+        result = {}
+
+        @interface_map.each do |tag, interface|
+          result[tag] = @interfaces_by_name[interface] or raise "#{interface} not found in IDL"
+        end
+
+        result
+      end
+
+      def parse_table(table)
+        headers = table.css("thead th").map { |e| e.inner_text.strip }
+
+        table.css("tbody tr").map do |row|
+          result = {}
+
+          row.css("th, td").each_with_index do |node, idx|
+            result[headers[idx]] = node.inner_text.strip
+          end
+
+          result
+        end
+      end
+
+      def parse_idl(str)
+        result = idl_parser.parse(str)
+
+        if result
+          result.build
+        else
+          errors << idl_parser.failure_reason
+          nil
+        end
+      end
+
+      def idl_parser
+        @idl_parser ||= WebIDL::Parser::IDLParser.new
+      end
+
+      def sorter
+        @idl_sroter ||= IDLSorter.new(@interfaces)
+      end
+
+    end # SpecExtractor
+  end # HTML
+end # Watir

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

@@ -0,0 +1,31 @@
+module Watir
+  module HTML
+    module Util
+
+      module_function
+
+
+      def classify(name)
+        if name =~ /^HTML(.+)Element$/
+          $1
+        else
+          name
+        end
+      end
+
+      SPECIALS = {
+        'img' => 'image'
+      }
+
+      def paramify(str)
+        if SPECIALS.has_key?(str)
+          SPECIALS[str]
+        else
+          classify(str).snake_case
+        end
+      end
+
+    end # Util
+  end # HTML
+end # Watir
+

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

@@ -0,0 +1,186 @@
+# encoding: utf-8
+
+module Watir
+  module HTML
+    class Visitor < WebIDL::RubySexpVisitor
+
+      def initialize
+        super
+
+        # When an interface has multiple IDL definitions in the spec, the inheritance is sometimes
+        # not repeated. So we'll keep track ourselves.
+        @inheritance_map = {}
+
+        @already_defined = []
+      end
+
+      #
+      # WebIDL visitor interface
+      #
+
+      def visit_interface(interface)
+        name   = interface.name
+        parent = interface.inherits.first
+
+        $stderr.puts name
+        return unless name =~ /^HTML/ && name !~ /(Collection|Document)$/
+
+        if name == "HTMLElement"
+          parent = 'Element'
+        elsif parent
+          @inheritance_map[name] ||= parent.name
+          parent = parent.name
+        else
+          parent = @inheritance_map[name] || return
+        end
+
+        [ :scope,
+          [:block,
+            element_class(interface.name, interface.members.select { |e| e.kind_of?(WebIDL::Ast::Attribute) }, parent),
+            collection_class(interface.name)
+          ]
+        ]
+      end
+
+      def visit_module(mod)
+        # ignored
+      end
+
+      def visit_implements_statement(stmt)
+        # ignored
+      end
+
+      # TODO: do everything in the visitor somehow?
+      # problem is we lack the tag name info while walking the interface AST
+      # #
+      # # Watir generator visitor interface
+      # #
+      #
+      # def visit_tag(tag_name, interface_name)
+      #   tag_string       = tag.inspect
+      #   singular         = Util.paramify(tag)
+      #   plural           = singular.pluralize
+      #   element_class    = Util.classify(interfaces.first.name)
+      #   collection_class = "#{element_class}Collection"
+      #
+      #   [:defn,
+      #    :a,
+      #    [:args, :"*args"],
+      #    [:scope,
+      #     [:block,
+      #      [:call,
+      #       [:const, :Anchor],
+      #       :new,
+      #       [:arglist,
+      #        [:self],
+      #        [:call,
+      #         [:call, nil, :extract_selector, [:arglist, [:lvar, :args]]],
+      #         :merge,
+      #         [:arglist, [:hash, [:lit, :tag_name], [:str, "a"]]]]]]]]]
+      # end
+
+      private
+
+      def element_class(name, attributes, parent)
+        [:class, Util.classify(name), [:const, Util.classify(parent)],
+          [:scope,
+            [:block, attributes_call(attributes)]
+          ]
+        ]
+      end
+
+      def collection_class(name)
+        return if @already_defined.include?(name)
+        @already_defined << name
+        name = Util.classify(name)
+
+        [:class, "#{name}Collection", [:const, :ElementCollection],
+          [:scope,
+            [:defn, :element_class,
+              [:args],
+              [:scope,
+                [:block, [:const, name]]
+              ]
+            ]
+          ]
+        ]
+      end
+
+      def attributes_call(attributes)
+        return if attributes.empty?
+
+        attrs = Hash.new { |hash, key| hash[key] = [] }
+        attributes.each do |a|
+          attrs[ruby_type_for(a.type)] << a.name.snake_case
+        end
+
+        call :attributes, [[:hash] + attrs.map { |type, names| [[:lit, type], literal_array(names)] }.flatten(1)]
+      end
+
+      def identifier_call(tag_name)
+        call :identifier, [literal_hash(:tag_name => tag_name)]
+      end
+
+      def container_call(name)
+        call :container_method,  [[:lit, Util.paramify(name).to_sym]]
+      end
+
+      def collection_call(name)
+        call :collection_method, [[:lit, Util.paramify(name).pluralize.to_sym]]
+      end
+
+      def literal_hash(hash)
+        [:hash] + hash.map { |k, v| [[:lit, k.to_sym], [:lit, v]] }.flatten(1)
+      end
+
+      def literal_array(arr)
+        [:array] + arr.map { |e| [:lit, e.to_sym] }
+      end
+
+      def call(name, args)
+        [:call, nil, name.to_sym, [:arglist] + args]
+      end
+
+      def ruby_type_for(type)
+        case type.name.to_s
+        when 'DOMString', 'any'
+          :string
+        when 'UnsignedLong', 'Long', 'Integer', 'Short', 'UnsignedShort'
+          :int
+        when 'Float', 'Double'
+          :float
+        when 'Function'
+          :function
+        when 'Boolean'
+          :bool
+        when 'Document'
+          :document
+        when 'DOMTokenList', 'DOMSettableTokenList'
+          :token_list
+        when 'DOMStringMap'
+          :string_map
+        when 'HTMLPropertiesCollection'
+          :properties_collection
+        when /HTML(.*)Element/
+          :html_element
+        when /HTML(.*)Collection/
+          :html_collection
+        when 'CSSStyleDeclaration'
+          :style
+        when /.+List$/
+          :list
+        when 'Date'
+          :date
+        when 'Element'
+          :element
+        when 'WindowProxy', 'ValidityState', 'MediaError', 'TimeRanges', 'Location', 'Any', 'TimedTrackArray', 'TimedTrack'
+          # probably completely wrong.
+          :string
+        else
+          raise "unknown type: #{type.name}"
+        end
+      end
+
+    end # Visitor
+  end # Support
+end # Watir

data/lib/watir-webdriver/locators/element_locator.rb

@@ -231,6 +231,10 @@ module Watir
       nil
     end
 
+    def all_elements
+      @wd.find_elements(:xpath => ".//*")
+    end
+
     def tag_name_matches?(element, tag_name)
       tag_name === element.tag_name
     end

data/lib/watir-webdriver/locators/text_field_locator.rb

@@ -12,7 +12,7 @@ module Watir
     def build_xpath(selectors)
       return if selectors.values.any? { |e| e.kind_of? Regexp }
 
-      selectors.delete(:tag_name) || raise("internal error: no tag_name?!")
+      selectors.delete(:tag_name)
 
       @building = :textarea
       textarea_attr_exp = attribute_expression(selectors)
@@ -58,4 +58,4 @@ module Watir
       !!(/^(input|textarea)$/ === element.tag_name)
     end
   end # TextFieldLocator
-end # Watir
+end # Watir

data/lib/watir-webdriver/xpath_support.rb

@@ -9,9 +9,9 @@ module Watir
 
     def element_by_xpath(xpath)
       e = wd.find_element(:xpath, xpath)
-      Watir.element_class_for(e.tag_name).new(self, :element, e)
+      Watir.element_class_for(e.tag_name).new(self, :element => e)
     rescue WebDriver::Error::NoSuchElementError
-      BaseElement.new(self, :xpath, xpath)
+      Element.new(self, :xpath => xpath)
     end
 
     #
@@ -20,10 +20,8 @@ module Watir
 
     def elements_by_xpath(xpath)
       wd.find_elements(:xpath, xpath).map do |e|
-        Watir.element_class_for(e.tag_name).new(self, :element, e)
+        Watir.element_class_for(e.tag_name).new(self, :element => e)
       end
-    rescue WebDriver::Error::NoSuchElementError
-      []
     end
 
   end # XpathSupport

data/lib/yard/handlers/watir.rb

@@ -0,0 +1,57 @@
+require "watir-webdriver/core_ext/string"
+
+module YARD
+  module Handlers
+    module Watir
+      #
+      # @private
+      # 
+      
+      class AttributesHandler < YARD::Handlers::Ruby::Base
+        handles method_call(:attributes)
+
+        TYPES = {
+          :string => "String",
+          :bool => "Boolean",
+          :int => "Integer"
+        }
+
+        def process
+          attributes = try_eval
+
+          if attributes.nil?
+            p :ignoring => statement.source, :in => namespace.to_s
+            return
+          end
+
+          TYPES.each do |type, return_type|
+            if attributes.member? type
+              create_attributes attributes[type], return_type
+            end
+          end
+        end
+
+        private
+
+        def create_attributes(names, return_type)
+          names.each do |attribute_name|
+            p :adding => "#{namespace}##{attribute_name}"
+            attribute_name = "#{attribute_name}?".to_sym if return_type == "Boolean"
+            register MethodObject.new(namespace, attribute_name, scope) do |o|
+              o.visibility = :public
+              o.explicit   = false
+              o.docstring.add_tag YARD::Tags::Tag.new(:return, "", return_type)
+            end
+          end
+        end
+
+        def try_eval
+          eval "{#{statement.parameters.source}}"
+        rescue SyntaxError, StandardError
+          nil
+        end
+
+      end # AttributesHandler
+    end # Watir
+  end # Handlers
+end

data/spec/{base_element_spec.rb → element_spec.rb}

@@ -1,6 +1,7 @@
-require File.dirname(__FILE__) + '/watirspec/spec_helper'
+require File.expand_path 'watirspec/spec_helper', File.dirname(__FILE__)
 
-describe Watir::BaseElement do
+
+describe Watir::Element do
 
   before :each do
     browser.goto("file://" + File.expand_path("html/keylogger.html", File.dirname(__FILE__)))