watir 1.4.1 → 7.3.0

data/lib/watir/exception.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Watir
+  module Exception
+    class Error < StandardError; end
+
+    # TODO: rename Object -> Element?
+    class UnknownObjectException < Error; end
+    class ObjectDisabledException < Error; end
+    class ObjectReadOnlyException < Error; end
+    class NoValueFoundException < Error; end
+    class NoMatchingWindowFoundException < Error; end
+    class UnknownFrameException < Error; end
+    class LocatorException < Error; end
+  end # Exception
+end # Watir

data/lib/watir/extensions/nokogiri.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Watir
+  class Browser
+    def text
+      doc = Nokogiri::HTML(body(index: 0).html)
+      doc.css('script').remove # encoding bug in older libxml?
+
+      doc.inner_text
+    end
+  end # Browser
+end # Watir

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Watir
+  module Generator
+    class Base
+      def generate(spec_url, io = StringIO.new)
+        @spec_url = spec_url
+        @io = 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_class.new
+      end
+
+      def extractor
+        @extractor ||= extractor_class.new(@spec_url)
+      end
+
+      def extract_spec
+        @tag2interfaces    = extractor.process
+        @sorted_interfaces = extractor.sorted_interfaces
+
+        raise "error extracting spec: #{extractor.errors.join("\n")}" if extractor.errors.any?
+      end
+
+      def cleanup_spec
+        ignored_tags.each do |tag|
+          @tag2interfaces.delete(tag)
+        end
+
+        ignored_interfaces.each do |interface|
+          @sorted_interfaces.reject! { |intf| intf.name == interface }
+        end
+
+        @sorted_interfaces.each do |intf|
+          intf.members.delete_if { |member| ignored_attributes.include?(member.name) }
+        end
+      end
+
+      def write_header
+        @io.puts "# Autogenerated from #{generator_implementation} specification. Edits may be lost."
+        @io.puts 'module Watir'
+      end
+
+      def write_class_defs
+        @sorted_interfaces.each do |interface|
+          interface = generator.generate(interface)
+          next if interface.empty?
+
+          interface.gsub!(/^\s+\n/, '') # remove empty lines
+          @io.puts indent(interface)
+          @io.puts "\n"
+        end
+      end
+
+      def write_container_methods
+        @io.puts "\n"
+        @io.puts indent('module Container')
+
+        @tag2interfaces.sort.each do |tag, interfaces|
+          raise "multiple interfaces for tag #{tag.inspect}" if interfaces.map(&:name).uniq.size != 1
+
+          tag_string       = tag.inspect
+          singular         = Util.paramify(visitor.classify_regexp, tag)
+          plural           = singular.pluralize
+          element_class    = Util.classify(visitor.classify_regexp, interfaces.first.name)
+          collection_class = "#{element_class}Collection"
+
+          # visitor.visit_tag(tag, interfaces.first.name) !?
+          @io.puts indent(<<~CODE, 2)
+
+            # @return [#{element_class}]
+            def #{singular}(opts = {})
+              #{element_class}.new(self, opts.merge(tag_name: #{tag_string}))
+            end
+            # @return [#{collection_class}]
+            def #{plural}(opts = {})
+              #{collection_class}.new(self, opts.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 # Base
+  end # Generator
+end # Watir

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'tsort'
+
+module Watir
+  module Generator
+    class Base
+      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 # Base
+  end # Generator
+end # Watir

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

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Watir
+  module Generator
+    class Base
+      class SpecExtractor
+        IDL_SELECTOR = "//pre[contains(@class, 'idl')]"
+
+        class InterfaceNotFound < StandardError; end
+
+        def initialize(uri)
+          @uri = uri
+        end
+
+        def process
+          download_and_parse
+          extract_idl_parts
+          extract_interface_map
+          drop_issued_interfaces
+          build_result
+        rescue StandardError
+          p errors
+          raise
+        end
+
+        def errors
+          @errors ||= []
+        end
+
+        #
+        # returns a topoligically sorted array of WebIDL::Ast::Interface objects
+        #
+
+        def sorted_interfaces
+          process if @interfaces.nil?
+
+          idl_sorter.sort.filter_map do |name|
+            @interfaces.find { |i| i.name == name } || puts("ignoring interface: #{name}")
+          end
+        end
+
+        def print_hierarchy
+          process if @interfaces.nil?
+          idl_sorter.print
+        end
+
+        def fetch_interface(interface)
+          @interfaces_by_name[interface] || raise(InterfaceNotFound, "#{interface} not found in IDL")
+        end
+
+        private
+
+        def download_and_parse
+          File.open(@uri) { |io| @doc = Nokogiri.HTML(io) }
+        end
+
+        def extract_idl_parts
+          parsed = @doc.search(IDL_SELECTOR).filter_map { |e| parse_idl(e.inner_text) }
+
+          implements = []
+          includes = []
+          @interfaces = []
+
+          parsed.flatten.each do |element|
+            case element
+            when WebIDL::Ast::Interface
+              @interfaces << element
+            when WebIDL::Ast::ImplementsStatement
+              implements << element
+            when WebIDL::Ast::IncludesStatement
+              includes << element
+            end
+          end
+
+          @interfaces_by_name = @interfaces.group_by(&:name)
+          apply_implements(implements)
+          apply_includes(includes)
+          merge_interfaces
+        end
+
+        def extract_interface_map
+          raise NotImplementedError
+        end
+
+        def drop_issued_interfaces
+          @interface_map.delete_if do |_, interface|
+            issued_interfaces.include?(interface)
+          end
+        end
+
+        def build_result
+          raise NotImplementedError
+        end
+
+        def parse_idl(str)
+          result = idl_parser.parse(str)
+
+          if result
+            result.build
+          else
+            errors << idl_parser.failure_reason
+            nil
+          end
+        end
+
+        def apply_implements(implements)
+          implements.each do |is|
+            implementor_name = is.implementor.gsub(/^::/, '')
+            implementee_name = is.implementee.gsub(/^::/, '')
+
+            begin
+              intf = fetch_interface(implementor_name).first
+              intf.implements << fetch_interface(implementee_name).first
+            rescue InterfaceNotFound => e
+              puts e.message
+            end
+          end
+        end
+
+        def apply_includes(includes)
+          includes.each do |is|
+            includer_name = is.includer.gsub(/^::/, '')
+            includee_name = is.includee.gsub(/^::/, '')
+
+            begin
+              intf = fetch_interface(includer_name).first
+              intf.includes << fetch_interface(includee_name).first
+            rescue InterfaceNotFound => e
+              puts e.message
+            end
+          end
+        end
+
+        def merge_interfaces
+          non_duplicates = @interfaces.uniq(&:name)
+          duplicates = @interfaces - non_duplicates
+
+          duplicates.each do |intf|
+            final = non_duplicates.find { |i| i.name == intf.name }
+            final.inherits += intf.inherits
+            final.members += intf.members
+            final.extended_attributes += intf.extended_attributes
+          end
+
+          @interfaces = non_duplicates
+        end
+
+        def idl_parser
+          @idl_parser ||= WebIDL::Parser::IDLParser.new
+        end
+
+        def idl_sorter
+          @idl_sorter ||= Base::IDLSorter.new(@interfaces)
+        end
+      end # SpecExtractor
+    end # Base
+  end # Generator
+end # Watir

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Watir
+  module Generator
+    module Util
+      module_function
+
+      def classify(regexp, str)
+        if str =~ regexp
+          Regexp.last_match(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,133 @@
+# frozen_string_literal: true
+
+module Watir
+  module Generator
+    class Base
+      class Visitor < WebIDL::RubySexpVisitor
+        STRING_TYPES = ['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',
+                        'Object', 'USVString', 'DOMString', 'any'].freeze
+        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
+
+          warn name
+          return if name !~ interface_regexp || name =~ /(Collection|Document)$/
+
+          parent = if force_inheritance.key?(name)
+                     force_inheritance[name]
+                   else
+                     @inheritance_map[name] ||= parent&.name
+                     return unless @inheritance_map[name]
+
+                     @inheritance_map[name]
+                   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
+
+        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 += interface.includes.flat_map(&:members)
+
+          members.select { |e| e.is_a?(WebIDL::Ast::Attribute) }.uniq(&:name)
+        end
+
+        def collection_class(name)
+          return if @already_defined.include?(name)
+
+          @already_defined << name
+          name = Util.classify(classify_regexp, name)
+
+          [:class, "#{name}Collection", %i[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 = if %w[httpEquiv contentEditable acceptCharset isContentEditable].include? attribute.name
+                  attribute.name.snake_case
+                else
+                  attribute.name.downcase
+                end
+
+          if attribute.type.name == :Boolean
+            str = Regexp.last_match(1) if str =~ /^is_(.+)/
+            str << '?'
+          end
+
+          str = 'for' if str == 'htmlfor'
+
+          str.to_sym
+        end
+
+        def ruby_type_for(type)
+          case type.name.to_s
+          when *STRING_TYPES
+            # probably completely wrong.
+            String
+          when 'UnsignedLong', 'Long', 'Integer', 'Short', 'UnsignedShort',
+              'SVGAnimatedLength'
+            Integer
+          when 'Float', /.*Double$/
+            Float
+          when 'Boolean'
+            'Boolean'
+          else
+            raise "unknown type: #{type.name}"
+          end
+        end
+      end # Visitor
+    end # Base
+  end # Generator
+end # Watir

data/lib/watir/generator/base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'open-uri'
+require 'webidl'
+require 'active_support/inflector'
+
+require 'watir/generator/base/generator'
+require 'watir/generator/base/idl_sorter'
+require 'watir/generator/base/spec_extractor'
+require 'watir/generator/base/util'
+require 'watir/generator/base/visitor'

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Watir
+  module Generator
+    class HTML < Base
+      private
+
+      def ignored_tags
+        %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 size selected? style
+           width height tHead tFoot link options selected caption]
+      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,52 @@
+# frozen_string_literal: true
+
+module Watir
+  module Generator
+    class HTML
+      class SpecExtractor < Base::SpecExtractor
+        private
+
+        def extract_interface_map
+          # http://www.whatwg.org/specs/web-apps/current-work/#elements-1
+          table = @doc.search("//h3[@id='index-elements']/following-sibling::table[1]").first
+          table || raise('could not find index-elements 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 # SpecExtractor
+    end # HTML
+  end # Generator
+end # Watir

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

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

data/lib/watir/generator/html.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+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/svg/generator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+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 unknown]
+      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