watir 5.0.0 → 6.0.0.beta1

data/lib/watir/generator/base/util.rb

@@ -0,0 +1,21 @@
+module Watir
+  module Generator
+    module Util
+
+      module_function
+
+      def classify(regexp, str)
+        if str =~ regexp
+          $1
+        else
+          str
+        end
+      end
+
+      def paramify(regexp, str)
+        classify(regexp, str).snake_case
+      end
+
+    end # Util
+  end # Generator
+end # Watir

data/lib/watir/generator/base/visitor.rb

@@ -0,0 +1,157 @@
+module Watir
+  module Generator
+    class Base::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 if name !~ interface_regexp || name =~ /(Collection|Document)$/
+
+        if force_inheritance.keys.include?(name)
+          parent = force_inheritance[name]
+        elsif parent
+          @inheritance_map[name] ||= parent.name
+          parent = parent.name
+        else
+          parent = @inheritance_map[name] || return
+        end
+
+        [ :scope,
+          [:block,
+            element_class(interface.name, extract_attributes(interface), 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(classify_regexp, tag)
+      #   plural           = singular.pluralize
+      #   element_class    = Util.classify(classify_regexp, 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(classify_regexp, name), [:const, Util.classify(classify_regexp, parent)],
+          *attribute_calls(attributes)
+        ]
+      end
+
+      def extract_attributes(interface)
+        members = interface.members
+        members += interface.implements.flat_map(&:members)
+
+        members.select { |e| e.kind_of?(WebIDL::Ast::Attribute) }
+      end
+
+      def collection_class(name)
+        return if @already_defined.include?(name)
+        @already_defined << name
+        name = Util.classify(classify_regexp, name)
+
+        [:class, "#{name}Collection", [:const, :ElementCollection]]
+      end
+
+      def attribute_calls(attributes)
+        attributes.map do |attribute|
+          call(:attribute, [
+            [:lit, ruby_type_for(attribute.type)],
+            [:lit, ruby_method_name_for(attribute)],
+            [:lit, attribute.name.to_sym]
+          ])
+        end
+      end
+
+      def call(name, args)
+        [:call, nil, name.to_sym, [:arglist] + args]
+      end
+
+      def ruby_method_name_for(attribute)
+        str = attribute.name.snake_case
+
+        if attribute.type.name == :Boolean
+          str = $1 if str =~ /^is_(.+)/
+          str << '?'
+        end
+
+        str = 'for' if str == 'html_for'
+
+        str.to_sym
+      end
+
+      def ruby_type_for(type)
+        case type.name.to_s
+        when 'DOMString', 'any'
+          String
+        when 'UnsignedLong', 'Long', 'Integer', 'Short', 'UnsignedShort',
+             'SVGAnimatedLength'
+          Fixnum
+        when 'Float', /.*Double$/
+          Float
+        when 'Boolean'
+          'Boolean'
+        when 'WindowProxy', 'ValidityState', 'TimeRanges', 'Location',
+             'Any', 'TimedTrackArray', 'TimedTrack', 'TextTrackArray', 'TextTrack',
+             /Media.+/, 'TextTrackKind', 'Function', /.*EventHandler$/,
+             'Document', 'DocumentFragment', 'DOMTokenList', 'DOMSettableTokenList',
+             'DOMStringMap', 'HTMLPropertiesCollection', /HTML.*Element/, /HTML.*Collection/,
+             'CSSStyleDeclaration',  /.+List$/, 'Date', 'Element', /DOM.+ReadOnly/,
+             /SVGAnimated.+/, /SVG.*Element/, /SVG.*Collection/, 'SVGViewSpec'
+          # probably completely wrong.
+          String
+        else
+          raise "unknown type: #{type.name}"
+        end
+      end
+
+    end # Visitor
+  end # Generator
+end # Watir

data/lib/watir/generator/html.rb

@@ -0,0 +1,15 @@
+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'
+  inflect.plural 'meta', 'metas'
+  inflect.plural 'details', 'detailses'
+  inflect.plural 'data', 'datas'
+  inflect.plural 'datalist', 'datalists'
+end
+
+require "watir/generator/html/generator"
+require "watir/generator/html/spec_extractor"
+require "watir/generator/html/visitor"

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

@@ -0,0 +1,36 @@
+module Watir
+  module Generator
+    class HTML < Base
+
+      private
+
+      def ignored_tags
+        # ignore the link element for now
+        %w(link)
+      end
+
+      def ignored_interfaces
+        ignored = ignored_tags.map { |tag| "HTML#{tag.capitalize}Element" }
+        # frame is implemented manually, see https://github.com/watir/watir/issues/204
+        ignored << 'HTMLFrameElement'
+      end
+
+      def ignored_attributes
+        %w(cells elements hash rows span text)
+      end
+
+      def generator_implementation
+        'HTML'
+      end
+
+      def visitor_class
+        HTML::Visitor
+      end
+
+      def extractor_class
+        HTML::SpecExtractor
+      end
+
+    end # Generator
+  end # HTML
+end # Watir

data/lib/watir/generator/html/spec_extractor.rb

@@ -0,0 +1,50 @@
+module Watir
+  module Generator
+    class HTML::SpecExtractor < Base::SpecExtractor
+
+      private
+
+      def extract_interface_map
+        # http://www.whatwg.org/specs/web-apps/current-work/#elements-1
+        table = @doc.search("//h3[@id='elements-3']/following-sibling::table[1]").first
+        table or raise "could not find elements-3 table"
+
+        @interface_map = {}
+
+        parse_table(table).each do |row|
+          row['Element'].split(", ").each { |tag| @interface_map[tag] = row['Interface'] }
+        end
+      end
+
+      def build_result
+        {}.tap do |result|
+          @interface_map.each do |tag, interface|
+            result[tag] = fetch_interface(interface)
+          end
+
+          # missing from the elements-1 table
+          result['frameset'] = fetch_interface('HTMLFrameSetElement')
+        end
+      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 issued_interfaces
+        []
+      end
+
+    end # HTML:;SpecExtractor
+  end # Generator
+end # Watir

data/lib/watir/generator/html/visitor.rb

@@ -0,0 +1,21 @@
+module Watir
+  module Generator
+    class HTML::Visitor < Base::Visitor
+
+      def classify_regexp
+        /^HTML(.+)Element$/
+      end
+
+      private
+
+      def interface_regexp
+        /^HTML/
+      end
+
+      def force_inheritance
+        { 'HTMLElement' => 'Element' }
+      end
+
+    end # HTML::Visitor
+  end # Generator
+end # Watir

data/lib/watir/generator/svg.rb

@@ -0,0 +1,7 @@
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.plural 'defs', 'defss'
+end
+
+require "watir/generator/svg/generator"
+require "watir/generator/svg/spec_extractor"
+require "watir/generator/svg/visitor"

data/lib/watir/generator/svg/generator.rb

@@ -0,0 +1,38 @@
+module Watir
+  module Generator
+    class SVG < Base
+
+      private
+
+      # fix collisions with HTML
+      #
+      # TODO: change generator so instead these classes
+      # are inherited from HTML ones
+
+      def ignored_tags
+        %w(a audio canvas iframe image script source style text title track video)
+      end
+
+      def ignored_interfaces
+        ignored_tags.map { |tag| "SVG#{tag.capitalize}Element" }
+      end
+
+      def ignored_attributes
+        []
+      end
+
+      def generator_implementation
+        'SVG'
+      end
+
+      def visitor_class
+        SVG::Visitor
+      end
+
+      def extractor_class
+        SVG::SpecExtractor
+      end
+
+    end # SVG
+  end # Generator
+end # Watir

data/lib/watir/generator/svg/spec_extractor.rb

@@ -0,0 +1,46 @@
+module Watir
+  module Generator
+    class SVG::SpecExtractor < Base::SpecExtractor
+
+      private
+
+      def extract_interface_map
+        list = @doc.search("//div[@id='chapter-eltindex']//ul/li")
+        list.any? or raise 'could not find elements list'
+
+        @interface_map = parse_list(list)
+      end
+
+      def build_result
+        {}.tap do |result|
+          @interface_map.each do |tag, interface|
+            result[tag] = fetch_interface(interface)
+          end
+        end
+      end
+
+      def parse_list(list)
+        {}.tap do |result|
+          list.each do |node|
+            tag_name = node.css('a span').inner_text.strip
+            id = node.css('a').attr('href').to_s
+
+            # Some interfaces are actually defined in different specs
+            # (for example, clipPath), so we ignore them for now
+            if id =~ /^#.+/
+              interface_css = 'div.element-summary a.idlinterface'
+              interface_name = @doc.css("#{id} #{interface_css}, #{id} ~ #{interface_css}").first.inner_text.strip
+
+              result[tag_name] = interface_name
+            end
+          end
+        end
+      end
+
+      def issued_interfaces
+        %w(SVGHatchElement SVGHatchPathElement SVGSolidColorElement)
+      end
+
+    end # SVG::SpecExtractor
+  end # Generator
+end # Watir

data/lib/watir/generator/svg/visitor.rb

@@ -0,0 +1,21 @@
+module Watir
+  module Generator
+    class SVG::Visitor < Base::Visitor
+
+      def classify_regexp
+        /^SVG(.+)Element$/
+      end
+
+      private
+
+      def interface_regexp
+        /^SVG.*Element$/
+      end
+
+      def force_inheritance
+        { 'SVGElement' => 'HTMLElement' }
+      end
+
+    end # SVG::Visitor
+  end # Generator
+end # Watir

data/lib/watir/has_window.rb

@@ -0,0 +1,53 @@
+module Watir
+  module HasWindow
+
+    #
+    # Returns browser windows array.
+    #
+    # @example
+    #   browser.windows(title: 'closeable window')
+    #
+    # @return [Array<Window>]
+    #
+
+    def windows(*args)
+      all = @driver.window_handles.map { |handle| Window.new(@driver, handle: handle) }
+
+      if args.empty?
+        all
+      else
+        filter_windows extract_selector(args), all
+      end
+    end
+
+    #
+    # Returns browser window.
+    #
+    # @example
+    #   browser.window(title: 'closeable window')
+    #
+    # @return [Window]
+    #
+
+    def window(*args, &blk)
+      win = Window.new @driver, extract_selector(args)
+
+      win.use(&blk) if block_given?
+
+      win
+    end
+
+    private
+
+    def filter_windows(selector, windows)
+      unless selector.keys.all? { |k| [:title, :url].include? k }
+        raise ArgumentError, "invalid window selector: #{selector.inspect}"
+      end
+
+      windows.select do |win|
+        selector.all? { |key, value| value === win.send(key) }
+      end
+    end
+
+  end # HasWindow
+end # Watir