watir 6.17.0 → 7.0.0.beta2

data/lib/watir/elements/iframe.rb

@@ -44,8 +44,9 @@ module Watir
     # @see Watir::Browser#execute_script
     #
 
-    def execute_script(script, *args)
+    def execute_script(script, *args, function_name: nil)
       args.map! do |e|
+        Watir.logger.info "Executing Script on Frame: #{function_name}" if function_name
         e.is_a?(Element) ? e.wait_until(&:exists?).wd : e
       end
       returned = driver.execute_script(script, *args)
@@ -90,12 +91,12 @@ module Watir
   end # FrameCollection
 
   module Container
-    def frame(*args)
-      Frame.new(self, extract_selector(args).merge(tag_name: 'frame'))
+    def frame(opts = {})
+      Frame.new(self, opts.merge(tag_name: 'frame'))
     end
 
-    def frames(*args)
-      FrameCollection.new(self, extract_selector(args).merge(tag_name: 'frame'))
+    def frames(opts = {})
+      FrameCollection.new(self, opts.merge(tag_name: 'frame'))
     end
   end # Container
 
@@ -125,7 +126,6 @@ module Watir
     def switch!
       @driver.switch_to.frame @element
       @browser.default_context = false
-      @browser.after_hooks.run
     rescue Selenium::WebDriver::Error::NoSuchFrameError => e
       raise UnknownFrameException, e.message
     end

data/lib/watir/elements/radio.rb

@@ -9,8 +9,8 @@ module Watir
     # Selects this radio button.
     #
 
-    def set
-      click unless set?
+    def set(bool = true)
+      click if bool && !set?
     end
     alias select set
 
@@ -39,12 +39,12 @@ module Watir
   end # Radio
 
   module Container
-    def radio(*args)
-      Radio.new(self, extract_selector(args).merge(tag_name: 'input', type: 'radio'))
+    def radio(opts = {})
+      Radio.new(self, opts.merge(tag_name: 'input', type: 'radio'))
     end
 
-    def radios(*args)
-      RadioCollection.new(self, extract_selector(args).merge(tag_name: 'input', type: 'radio'))
+    def radios(opts = {})
+      RadioCollection.new(self, opts.merge(tag_name: 'input', type: 'radio'))
     end
   end # Container
 

data/lib/watir/elements/select.rb

@@ -5,7 +5,7 @@ module Watir
     #
 
     def clear
-      raise Exception::Error, 'you can only clear multi-selects' unless multiple?
+      raise Exception::Error, 'you can only clear multi-selects' unless multiple_select_list?
 
       selected_options.each(&:click)
     end
@@ -18,7 +18,7 @@ module Watir
     #
 
     def include?(str_or_rx)
-      option(text: str_or_rx).exist? || option(label: str_or_rx).exist?
+      option(text: str_or_rx).exist? || option(label: str_or_rx).exist? || option(value: str_or_rx).exist?
     end
 
     #
@@ -29,23 +29,16 @@ module Watir
     # @return [String] The text of the option selected. If multiple options match, returns the first match.
     #
 
-    def select(*str_or_rx)
-      results = str_or_rx.flatten.map { |v| select_by v }
-      results.first
-    end
+    def select(*str_or_rx, text: nil, value: nil, label: nil)
+      key, value = parse_select_args(str_or_rx, text, value, label)
 
-    #
-    # Select all options whose text or label matches the given string.
-    #
-    # @param [String, Regexp] str_or_rx
-    # @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
-    # @return [String] The text of the first option selected.
-    #
-
-    def select_all(*str_or_rx)
-      results = str_or_rx.flatten.map { |v| select_all_by v }
-      results.first
+      if value.size > 1 || value.first.is_a?(Array)
+        value.flatten.map { |v| select_all_by key, v }.first
+      else
+        select_matching([find_option(key, value.flatten.first)])
+      end
     end
+    alias set select
 
     #
     # Uses JavaScript to select the option whose text matches the given string.
@@ -54,36 +47,14 @@ module Watir
     # @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
     #
 
-    def select!(*str_or_rx)
-      results = str_or_rx.flatten.map { |v| select_by!(v, :single) }
-      results.first
-    end
-
-    #
-    # Uses JavaScript to select all options whose text matches the given string.
-    #
-    # @param [String, Regexp] str_or_rx
-    # @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
-    #
-
-    def select_all!(*str_or_rx)
-      results = str_or_rx.flatten.map { |v| select_by!(v, :multiple) }
-      results.first
-    end
+    def select!(*str_or_rx, text: nil, value: nil, label: nil)
+      key, value = parse_select_args(str_or_rx, text, value, label)
 
-    #
-    # Selects the option(s) whose value attribute matches the given string.
-    #
-    # @see +select+
-    #
-    # @param [String, Regexp] str_or_rx
-    # @raise [Watir::Exception::NoValueFoundException] if the value does not exist.
-    # @return [String] The option selected. If multiple options match, returns the first match
-    #
-
-    def select_value(str_or_rx)
-      Watir.logger.deprecate '#select_value', '#select', ids: [:select_value]
-      select_by str_or_rx
+      if value.size > 1 || value.first.is_a?(Array)
+        value.flatten.map { |v| select_by! key, v, :multiple }.first
+      else
+        value.flatten.map { |v| select_by! key, v, :single }.first
+      end
     end
 
     #
@@ -94,16 +65,10 @@ module Watir
     # @return [Boolean]
     #
 
-    def selected?(str_or_rx)
-      by_text = options(text: str_or_rx)
-      return true if by_text.find(&:selected?)
-
-      by_label = options(label: str_or_rx)
-      return true if by_label.find(&:selected?)
+    def selected?(*str_or_rx, text: nil, value: nil, label: nil)
+      key, value = parse_select_args(str_or_rx, text, value, label)
 
-      return false unless (by_text.size + by_label.size).zero?
-
-      raise(UnknownObjectException, "Unable to locate option matching #{str_or_rx.inspect}")
+      find_option(key, value.first).selected?
     end
 
     #
@@ -114,8 +79,7 @@ module Watir
     #
 
     def value
-      option = selected_options.first
-      option&.value
+      selected_options.first&.value
     end
 
     #
@@ -125,9 +89,9 @@ module Watir
     # @return [String, nil]
     #
 
+    # TODO: What is default behavior without #first ?
     def text
-      option = selected_options.first
-      option&.text
+      selected_options.first&.text
     end
 
     # Returns an array of currently selected options.
@@ -141,20 +105,29 @@ module Watir
 
     private
 
-    def select_by(str_or_rx)
-      found = find_options(:value, str_or_rx)
+    def multiple_select_list?
+      @multiple_select = @multiple_select.nil? ? multiple? : @multiple_select
+    end
 
-      if found.size > 1
-        Watir.logger.deprecate 'Selecting Multiple Options with #select', '#select_all',
-                               ids: [:select_by]
-      end
-      select_matching(found)
+    def parse_select_args(str_or_rx, text, value, label)
+      selectors = {}
+      selectors[:any] = str_or_rx unless str_or_rx.empty?
+      selectors[:text] = Array[text] if text
+      selectors[:value] = Array[value] if value
+      selectors[:label] = Array[label] if label
+
+      raise ArgumentError, "too many arguments used for Select#select: #{selectors}" if selectors.size > 1
+
+      selectors.first
     end
 
-    def select_by!(str_or_rx, number)
+    def select_by!(key, str_or_rx, number)
+      str_or_rx = type_check(str_or_rx)
+
       js_rx = process_str_or_rx(str_or_rx)
+      approaches = key == :any ? %w[Text Label Value] : [key.to_s.capitalize]
 
-      %w[Text Label Value].each do |approach|
+      approaches.each do |approach|
         element_call { execute_js("selectOptions#{approach}", self, js_rx, number.to_s) }
         return selected_options.first.text if matching_option?(approach.downcase, str_or_rx)
       end
@@ -190,44 +163,43 @@ module Watir
       false
     end
 
-    def select_all_by(str_or_rx)
-      raise Error, 'you can only use #select_all on multi-selects' unless multiple?
-
-      found = find_options :text, str_or_rx
+    def select_all_by(key, str_or_rx)
+      raise Error, 'you can only use #select_all on multi-selects' unless multiple_select_list?
 
-      select_matching(found)
+      select_matching(find_options(key, str_or_rx))
     end
 
-    def find_options(how, str_or_rx)
-      wait_while do
-        case str_or_rx
-        when String, Numeric, Regexp
-          @found = how == :value ? options(value: str_or_rx) : []
-          @found = options(text: str_or_rx) if @found.empty?
-          @found = options(label: str_or_rx) if @found.empty?
-          @found.empty? && Watir.relaxed_locate?
-        else
-          raise TypeError, "expected String or Regexp, got #{str_or_rx.inspect}:#{str_or_rx.class}"
-        end
-      end
-      # TODO: Remove conditional when remove relaxed_locate toggle
-      return @found unless @found.empty?
+    def find_option(key, str_or_rx)
+      val = type_check(str_or_rx)
 
+      option(key => val).wait_until(&:exists?)
+    rescue Wait::TimeoutError
       raise_no_value_found(str_or_rx)
+    end
+
+    def find_options(key, str_or_rx)
+      val = type_check(str_or_rx)
+
+      options(key => val).wait_until(&:exists?)
     rescue Wait::TimeoutError
       raise_no_value_found(str_or_rx)
     end
 
+    def type_check(str_or_rx)
+      str_or_rx = str_or_rx.to_s if str_or_rx.is_a?(Numeric)
+      return str_or_rx if [String, Regexp].any? { |k| str_or_rx.is_a?(k) }
+
+      raise TypeError, "expected String, Numeric or Regexp, got #{str_or_rx.inspect}:#{str_or_rx.class}"
+    end
+
     # TODO: Consider locating the Select List before throwing the exception
     def raise_no_value_found(str_or_rx)
       raise NoValueFoundException, "#{str_or_rx.inspect} not found in #{inspect}"
     end
 
     def select_matching(elements)
-      elements = [elements.first] unless multiple?
       elements.each { |e| e.click unless e.selected? }
-      # TODO: this can go back to #exist? after `:stale_exists` deprecation removed
-      elements.first.stale? ? '' : elements.first.text
+      elements.first.exists? ? elements.first.text : ''
     end
   end # Select
 

data/lib/watir/elements/svg_elements.rb

@@ -255,242 +255,242 @@ module Watir
   module Container
 
     # @return [Circle]
-    def circle(*args)
-      Circle.new(self, extract_selector(args).merge(tag_name: "circle"))
+    def circle(opts = {})
+      Circle.new(self, opts.merge(tag_name: "circle"))
     end
     # @return [CircleCollection]
-    def circles(*args)
-      CircleCollection.new(self, extract_selector(args).merge(tag_name: "circle"))
+    def circles(opts = {})
+      CircleCollection.new(self, opts.merge(tag_name: "circle"))
     end
     Watir.tag_to_class[:circle] = Circle
 
     # @return [Defs]
-    def defs(*args)
-      Defs.new(self, extract_selector(args).merge(tag_name: "defs"))
+    def defs(opts = {})
+      Defs.new(self, opts.merge(tag_name: "defs"))
     end
     # @return [DefsCollection]
-    def defss(*args)
-      DefsCollection.new(self, extract_selector(args).merge(tag_name: "defs"))
+    def defss(opts = {})
+      DefsCollection.new(self, opts.merge(tag_name: "defs"))
     end
     Watir.tag_to_class[:defs] = Defs
 
     # @return [Desc]
-    def desc(*args)
-      Desc.new(self, extract_selector(args).merge(tag_name: "desc"))
+    def desc(opts = {})
+      Desc.new(self, opts.merge(tag_name: "desc"))
     end
     # @return [DescCollection]
-    def descs(*args)
-      DescCollection.new(self, extract_selector(args).merge(tag_name: "desc"))
+    def descs(opts = {})
+      DescCollection.new(self, opts.merge(tag_name: "desc"))
     end
     Watir.tag_to_class[:desc] = Desc
 
     # @return [Ellipse]
-    def ellipse(*args)
-      Ellipse.new(self, extract_selector(args).merge(tag_name: "ellipse"))
+    def ellipse(opts = {})
+      Ellipse.new(self, opts.merge(tag_name: "ellipse"))
     end
     # @return [EllipseCollection]
-    def ellipses(*args)
-      EllipseCollection.new(self, extract_selector(args).merge(tag_name: "ellipse"))
+    def ellipses(opts = {})
+      EllipseCollection.new(self, opts.merge(tag_name: "ellipse"))
     end
     Watir.tag_to_class[:ellipse] = Ellipse
 
     # @return [ForeignObject]
-    def foreign_object(*args)
-      ForeignObject.new(self, extract_selector(args).merge(tag_name: "foreignObject"))
+    def foreign_object(opts = {})
+      ForeignObject.new(self, opts.merge(tag_name: "foreignObject"))
     end
     # @return [ForeignObjectCollection]
-    def foreign_objects(*args)
-      ForeignObjectCollection.new(self, extract_selector(args).merge(tag_name: "foreignObject"))
+    def foreign_objects(opts = {})
+      ForeignObjectCollection.new(self, opts.merge(tag_name: "foreignObject"))
     end
     Watir.tag_to_class[:foreignObject] = ForeignObject
 
     # @return [G]
-    def g(*args)
-      G.new(self, extract_selector(args).merge(tag_name: "g"))
+    def g(opts = {})
+      G.new(self, opts.merge(tag_name: "g"))
     end
     # @return [GCollection]
-    def gs(*args)
-      GCollection.new(self, extract_selector(args).merge(tag_name: "g"))
+    def gs(opts = {})
+      GCollection.new(self, opts.merge(tag_name: "g"))
     end
     Watir.tag_to_class[:g] = G
 
     # @return [Line]
-    def line(*args)
-      Line.new(self, extract_selector(args).merge(tag_name: "line"))
+    def line(opts = {})
+      Line.new(self, opts.merge(tag_name: "line"))
     end
     # @return [LineCollection]
-    def lines(*args)
-      LineCollection.new(self, extract_selector(args).merge(tag_name: "line"))
+    def lines(opts = {})
+      LineCollection.new(self, opts.merge(tag_name: "line"))
     end
     Watir.tag_to_class[:line] = Line
 
     # @return [LinearGradient]
-    def linear_gradient(*args)
-      LinearGradient.new(self, extract_selector(args).merge(tag_name: "linearGradient"))
+    def linear_gradient(opts = {})
+      LinearGradient.new(self, opts.merge(tag_name: "linearGradient"))
     end
     # @return [LinearGradientCollection]
-    def linear_gradients(*args)
-      LinearGradientCollection.new(self, extract_selector(args).merge(tag_name: "linearGradient"))
+    def linear_gradients(opts = {})
+      LinearGradientCollection.new(self, opts.merge(tag_name: "linearGradient"))
     end
     Watir.tag_to_class[:linearGradient] = LinearGradient
 
     # @return [Marker]
-    def marker(*args)
-      Marker.new(self, extract_selector(args).merge(tag_name: "marker"))
+    def marker(opts = {})
+      Marker.new(self, opts.merge(tag_name: "marker"))
     end
     # @return [MarkerCollection]
-    def markers(*args)
-      MarkerCollection.new(self, extract_selector(args).merge(tag_name: "marker"))
+    def markers(opts = {})
+      MarkerCollection.new(self, opts.merge(tag_name: "marker"))
     end
     Watir.tag_to_class[:marker] = Marker
 
     # @return [Metadata]
-    def metadata(*args)
-      Metadata.new(self, extract_selector(args).merge(tag_name: "metadata"))
+    def metadata(opts = {})
+      Metadata.new(self, opts.merge(tag_name: "metadata"))
     end
     # @return [MetadataCollection]
-    def metadatas(*args)
-      MetadataCollection.new(self, extract_selector(args).merge(tag_name: "metadata"))
+    def metadatas(opts = {})
+      MetadataCollection.new(self, opts.merge(tag_name: "metadata"))
     end
     Watir.tag_to_class[:metadata] = Metadata
 
     # @return [Path]
-    def path(*args)
-      Path.new(self, extract_selector(args).merge(tag_name: "path"))
+    def path(opts = {})
+      Path.new(self, opts.merge(tag_name: "path"))
     end
     # @return [PathCollection]
-    def paths(*args)
-      PathCollection.new(self, extract_selector(args).merge(tag_name: "path"))
+    def paths(opts = {})
+      PathCollection.new(self, opts.merge(tag_name: "path"))
     end
     Watir.tag_to_class[:path] = Path
 
     # @return [Pattern]
-    def pattern(*args)
-      Pattern.new(self, extract_selector(args).merge(tag_name: "pattern"))
+    def pattern(opts = {})
+      Pattern.new(self, opts.merge(tag_name: "pattern"))
     end
     # @return [PatternCollection]
-    def patterns(*args)
-      PatternCollection.new(self, extract_selector(args).merge(tag_name: "pattern"))
+    def patterns(opts = {})
+      PatternCollection.new(self, opts.merge(tag_name: "pattern"))
     end
     Watir.tag_to_class[:pattern] = Pattern
 
     # @return [Polygon]
-    def polygon(*args)
-      Polygon.new(self, extract_selector(args).merge(tag_name: "polygon"))
+    def polygon(opts = {})
+      Polygon.new(self, opts.merge(tag_name: "polygon"))
     end
     # @return [PolygonCollection]
-    def polygons(*args)
-      PolygonCollection.new(self, extract_selector(args).merge(tag_name: "polygon"))
+    def polygons(opts = {})
+      PolygonCollection.new(self, opts.merge(tag_name: "polygon"))
     end
     Watir.tag_to_class[:polygon] = Polygon
 
     # @return [Polyline]
-    def polyline(*args)
-      Polyline.new(self, extract_selector(args).merge(tag_name: "polyline"))
+    def polyline(opts = {})
+      Polyline.new(self, opts.merge(tag_name: "polyline"))
     end
     # @return [PolylineCollection]
-    def polylines(*args)
-      PolylineCollection.new(self, extract_selector(args).merge(tag_name: "polyline"))
+    def polylines(opts = {})
+      PolylineCollection.new(self, opts.merge(tag_name: "polyline"))
     end
     Watir.tag_to_class[:polyline] = Polyline
 
     # @return [RadialGradient]
-    def radial_gradient(*args)
-      RadialGradient.new(self, extract_selector(args).merge(tag_name: "radialGradient"))
+    def radial_gradient(opts = {})
+      RadialGradient.new(self, opts.merge(tag_name: "radialGradient"))
     end
     # @return [RadialGradientCollection]
-    def radial_gradients(*args)
-      RadialGradientCollection.new(self, extract_selector(args).merge(tag_name: "radialGradient"))
+    def radial_gradients(opts = {})
+      RadialGradientCollection.new(self, opts.merge(tag_name: "radialGradient"))
     end
     Watir.tag_to_class[:radialGradient] = RadialGradient
 
     # @return [Rect]
-    def rect(*args)
-      Rect.new(self, extract_selector(args).merge(tag_name: "rect"))
+    def rect(opts = {})
+      Rect.new(self, opts.merge(tag_name: "rect"))
     end
     # @return [RectCollection]
-    def rects(*args)
-      RectCollection.new(self, extract_selector(args).merge(tag_name: "rect"))
+    def rects(opts = {})
+      RectCollection.new(self, opts.merge(tag_name: "rect"))
     end
     Watir.tag_to_class[:rect] = Rect
 
     # @return [Stop]
-    def stop(*args)
-      Stop.new(self, extract_selector(args).merge(tag_name: "stop"))
+    def stop(opts = {})
+      Stop.new(self, opts.merge(tag_name: "stop"))
     end
     # @return [StopCollection]
-    def stops(*args)
-      StopCollection.new(self, extract_selector(args).merge(tag_name: "stop"))
+    def stops(opts = {})
+      StopCollection.new(self, opts.merge(tag_name: "stop"))
     end
     Watir.tag_to_class[:stop] = Stop
 
     # @return [SVG]
-    def svg(*args)
-      SVG.new(self, extract_selector(args).merge(tag_name: "svg"))
+    def svg(opts = {})
+      SVG.new(self, opts.merge(tag_name: "svg"))
     end
     # @return [SVGCollection]
-    def svgs(*args)
-      SVGCollection.new(self, extract_selector(args).merge(tag_name: "svg"))
+    def svgs(opts = {})
+      SVGCollection.new(self, opts.merge(tag_name: "svg"))
     end
     Watir.tag_to_class[:svg] = SVG
 
     # @return [Switch]
-    def switch(*args)
-      Switch.new(self, extract_selector(args).merge(tag_name: "switch"))
+    def switch(opts = {})
+      Switch.new(self, opts.merge(tag_name: "switch"))
     end
     # @return [SwitchCollection]
-    def switches(*args)
-      SwitchCollection.new(self, extract_selector(args).merge(tag_name: "switch"))
+    def switches(opts = {})
+      SwitchCollection.new(self, opts.merge(tag_name: "switch"))
     end
     Watir.tag_to_class[:switch] = Switch
 
     # @return [Symbol]
-    def symbol(*args)
-      Symbol.new(self, extract_selector(args).merge(tag_name: "symbol"))
+    def symbol(opts = {})
+      Symbol.new(self, opts.merge(tag_name: "symbol"))
     end
     # @return [SymbolCollection]
-    def symbols(*args)
-      SymbolCollection.new(self, extract_selector(args).merge(tag_name: "symbol"))
+    def symbols(opts = {})
+      SymbolCollection.new(self, opts.merge(tag_name: "symbol"))
     end
     Watir.tag_to_class[:symbol] = Symbol
 
     # @return [TextPath]
-    def text_path(*args)
-      TextPath.new(self, extract_selector(args).merge(tag_name: "textPath"))
+    def text_path(opts = {})
+      TextPath.new(self, opts.merge(tag_name: "textPath"))
     end
     # @return [TextPathCollection]
-    def text_paths(*args)
-      TextPathCollection.new(self, extract_selector(args).merge(tag_name: "textPath"))
+    def text_paths(opts = {})
+      TextPathCollection.new(self, opts.merge(tag_name: "textPath"))
     end
     Watir.tag_to_class[:textPath] = TextPath
 
     # @return [TSpan]
-    def tspan(*args)
-      TSpan.new(self, extract_selector(args).merge(tag_name: "tspan"))
+    def tspan(opts = {})
+      TSpan.new(self, opts.merge(tag_name: "tspan"))
     end
     # @return [TSpanCollection]
-    def tspans(*args)
-      TSpanCollection.new(self, extract_selector(args).merge(tag_name: "tspan"))
+    def tspans(opts = {})
+      TSpanCollection.new(self, opts.merge(tag_name: "tspan"))
     end
     Watir.tag_to_class[:tspan] = TSpan
 
     # @return [Use]
-    def use(*args)
-      Use.new(self, extract_selector(args).merge(tag_name: "use"))
+    def use(opts = {})
+      Use.new(self, opts.merge(tag_name: "use"))
     end
     # @return [UseCollection]
-    def uses(*args)
-      UseCollection.new(self, extract_selector(args).merge(tag_name: "use"))
+    def uses(opts = {})
+      UseCollection.new(self, opts.merge(tag_name: "use"))
     end
     Watir.tag_to_class[:use] = Use
 
     # @return [View]
-    def view(*args)
-      View.new(self, extract_selector(args).merge(tag_name: "view"))
+    def view(opts = {})
+      View.new(self, opts.merge(tag_name: "view"))
     end
     # @return [ViewCollection]
-    def views(*args)
-      ViewCollection.new(self, extract_selector(args).merge(tag_name: "view"))
+    def views(opts = {})
+      ViewCollection.new(self, opts.merge(tag_name: "view"))
     end
     Watir.tag_to_class[:view] = View
   end # Container