watir 6.13.0 → 6.14.0

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

@@ -1,12 +1,11 @@
 module Watir
   module Generator
     module Util
-
       module_function
 
       def classify(regexp, str)
         if str =~ regexp
-          $1
+          Regexp.last_match(1)
         else
           str
         end
@@ -15,7 +14,6 @@ module Watir
       def paramify(regexp, str)
         classify(regexp, str).snake_case
       end
-
     end # Util
   end # Generator
 end # Watir

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

@@ -1,162 +1,162 @@
 module Watir
   module Generator
-    class Base::Visitor < WebIDL::RubySexpVisitor
+    module 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'].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
 
-      def initialize
-        super
+        #
+        # WebIDL visitor interface
+        #
 
-        # When an interface has multiple IDL definitions in the spec, the inheritance is sometimes
-        # not repeated. So we'll keep track ourselves.
-        @inheritance_map = {}
+        def visit_interface(interface)
+          name   = interface.name
+          parent = interface.inherits.first
 
-        @already_defined = []
-      end
+          warn name
+          return if name !~ interface_regexp || name =~ /(Collection|Document)$/
 
-      #
-      # WebIDL visitor interface
-      #
+          parent = if force_inheritance.key?(name)
+                     force_inheritance[name]
+                   else
+                     @inheritance_map[name] ||= parent&.name
+                     return unless @inheritance_map[name]
 
-      def visit_interface(interface)
-        name   = interface.name
-        parent = interface.inherits.first
+                     @inheritance_map[name]
+                   end
 
-        $stderr.puts name
-        return if name !~ interface_regexp || name =~ /(Collection|Document)$/
+          [:scope,
+           [:block,
+            element_class(interface.name, extract_attributes(interface), parent),
+            collection_class(interface.name)]]
+        end
 
-        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
+        def visit_module(mod)
+          # ignored
         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) }.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", [: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]
-          ])
+        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 += interface.includes.flat_map(&:members)
+
+          members.select { |e| e.is_a?(WebIDL::Ast::Attribute) }.uniq(&:name)
         end
-      end
 
-      def call(name, args)
-        [:call, nil, name.to_sym, [:arglist] + args]
-      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 ruby_method_name_for(attribute)
-        str = if %w(httpEquiv contentEditable acceptCharset isContentEditable).include? attribute.name
-          attribute.name.snake_case
-        else
-          attribute.name.downcase
+        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
 
-        if attribute.type.name == :Boolean
-          str = $1 if str =~ /^is_(.+)/
-          str << '?'
+        def call(name, args)
+          [:call, nil, name.to_sym, [:arglist] + args]
         end
 
-        str = 'for' if str == 'htmlfor'
-
-        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'
-          Integer
-        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',
-             'Object', 'USVString'
-          # probably completely wrong.
-          String
-        else
-          raise "unknown type: #{type.name}"
+        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
-      end
 
-    end # Visitor
+        def ruby_type_for(type)
+          case type.name.to_s
+          when 'DOMString', 'any'
+            String
+          when 'UnsignedLong', 'Long', 'Integer', 'Short', 'UnsignedShort',
+              'SVGAnimatedLength'
+            Integer
+          when 'Float', /.*Double$/
+            Float
+          when 'Boolean'
+            'Boolean'
+          when *STRING_TYPES
+            # probably completely wrong.
+            String
+          else
+            raise "unknown type: #{type.name}"
+          end
+        end
+      end # Visitor
+    end # Base
   end # Generator
 end # Watir

data/lib/watir/generator/html.rb

@@ -3,13 +3,13 @@ ActiveSupport::Inflector.inflections do |inflect|
   inflect.plural 'tbody', 'tbodys'
   inflect.plural 'canvas', 'canvases'
   inflect.plural 'ins', 'inses'
-  inflect.plural /^s$/, 'ss'
+  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"
+require 'watir/generator/html/generator'
+require 'watir/generator/html/spec_extractor'
+require 'watir/generator/html/visitor'

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

@@ -1,12 +1,11 @@
 module Watir
   module Generator
     class HTML < Base
-
       private
 
       def ignored_tags
         # ignore the link element for now
-        %w(link)
+        %w[link]
       end
 
       def ignored_interfaces
@@ -16,7 +15,7 @@ module Watir
       end
 
       def ignored_attributes
-        %w(cells elements hash rows span text size selected? style width height tHead tFoot link options)
+        %w[cells elements hash rows span text size selected? style width height tHead tFoot link options]
       end
 
       def generator_implementation
@@ -30,7 +29,6 @@ module Watir
       def extractor_class
         HTML::SpecExtractor
       end
-
     end # Generator
   end # HTML
 end # Watir

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

@@ -1,50 +1,50 @@
 module Watir
   module Generator
-    class HTML::SpecExtractor < Base::SpecExtractor
+    module HTML
+      class SpecExtractor < Base::SpecExtractor
+        private
 
-      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')
 
-      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 or raise "could not find index-elements table"
+          @interface_map = {}
 
-        @interface_map = {}
-
-        parse_table(table).each do |row|
-          row['Element'].split(", ").each { |tag| @interface_map[tag] = row['Interface'] }
+          parse_table(table).each do |row|
+            row['Element'].split(', ').each { |tag| @interface_map[tag] = row['Interface'] }
+          end
         end
-      end
 
-      def build_result
-        {}.tap do |result|
-          @interface_map.each do |tag, interface|
-            result[tag] = fetch_interface(interface)
-          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')
+            # missing from the elements-1 table
+            result['frameset'] = fetch_interface('HTMLFrameSetElement')
+          end
         end
-      end
 
-      def parse_table(table)
-        headers = table.css("thead th").map { |e| e.inner_text.strip }
+        def parse_table(table)
+          headers = table.css('thead th').map { |e| e.inner_text.strip }
 
-        table.css("tbody tr").map do |row|
-          result = {}
+          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
+            row.css('th, td').each_with_index do |node, idx|
+              result[headers[idx]] = node.inner_text.strip
+            end
 
-          result
+            result
+          end
         end
-      end
 
-      def issued_interfaces
-        []
-      end
-
-    end # HTML:;SpecExtractor
+        def issued_interfaces
+          []
+        end
+      end # SpecExtractor
+    end # HTML
   end # Generator
 end # Watir