ayanko-watir-webdriver 0.1.1.1

data/lib/watir-webdriver/html.rb

@@ -0,0 +1,19 @@
+require "nokogiri"
+require "open-uri"
+require "pp"
+require "webidl"
+require "active_support/inflector"
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.plural 'body', 'bodys'
+  inflect.plural 'tbody', 'tbodys'
+  inflect.plural 'canvas', 'canvases'
+  inflect.plural 'ins', 'inses'
+  inflect.plural /^s$/, 'ss'
+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| line.empty? ? 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

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,22 @@
+module Watir
+  module HTML
+    module Util
+
+      module_function
+
+      def classify(name)
+        if name =~ /^HTML(.+)Element$/
+          $1
+        else
+          name
+        end
+      end
+
+      def paramify(str)
+        classify(str).snake_case
+      end
+
+    end # Util
+  end # HTML
+end # Watir
+

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

@@ -0,0 +1,174 @@
+# 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.to_sym
+        end
+
+        call :attributes, [literal_hash(attrs)]
+      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