domkey 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45e6ac05a48d93eede629f82f2a5b04b14037f62
-  data.tar.gz: 9c3b5d281b8b000852489e1933de6b855b2975e3
+  metadata.gz: 0468e0993e03c228863792b2979fc0518aea17db
+  data.tar.gz: d36475ac117f17891905d01328dadca7bc08fe90
 SHA512:
-  metadata.gz: aa5af099b7354c11538d238e9c4a59eb91cf41a7f7845fe10bd92659af309e7e65ebf1630d722952e17a39ca1a0e9a790e955a00d91df35a074ea9de9b83d3d1
-  data.tar.gz: 2fe75c7ca69ba9f0656491cea2a358a048f815b5da77bc7d614425c4a4a5a353b653364b4f13b522e2a366de699744389e3244dcde80822a7ed9fd6ab727fe56
+  metadata.gz: ef11d67c2261cc2e7f4228bbe1f2466a1d82f4ebb8eedd895850c9e48d109080506ae91f6a40055184308e04f24395aedc5c81d0f48d5d7ba866d23b78a4e45d
+  data.tar.gz: 5b613799843aedb4959c422fe4dfcf91c28740903c78e4e86dc4b40e971ff803a77567df785e066ae702069bcc5becdb56246c98a7feba1012bc0e96b8cf49e4

data/lib/domkey/exception.rb

@@ -2,5 +2,9 @@ module Domkey
   module Exception
     class Error < StandardError
     end
+    class NotImplementedError < Error
+    end
+    class NotFoundError < Error
+    end
   end
 end

data/lib/domkey/version.rb

@@ -1,3 +1,3 @@
 module Domkey
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/domkey/view.rb

@@ -2,6 +2,7 @@ require 'domkey/view/page_object'
 require 'domkey/view/page_object_collection'
 require 'domkey/view/radio_group'
 require 'domkey/view/checkbox_group'
+require 'domkey/view/select_list'
 require 'domkey/view/cargo'
 
 module Domkey

data/lib/domkey/view/checkbox_group.rb

@@ -1,74 +1,23 @@
-require 'domkey/view/labeled_group'
+require 'domkey/view/option_selectable_group'
+
 module Domkey
 
   module View
 
-    # Acts like OptionSelectable object
     # CheckboxGroup allows you to interact with PageObjectCollection of checkboxes as a single PageObject.
-    # Checkboxes collection is constrained by the same name attribute and acts like on object.
-    # It behaves like a Multi Select list.
-    # It can none, one or more options selected
-    class CheckboxGroup < PageObjectCollection
-
-      # clears all options and sets only the desired value(s)
-      # @param [String, Regexp] find value attribute or match value and set that checkbox
-      # @param [Array<String, Regexp>] find each value attribute and set each checkbox
-      # @param [False] uncheck any checked checkboxes
-      def set value
-        validate_scope
-        element.each { |e| e.clear }
-        return unless value
-        [*value].each do |v|
-          e = case v
-              when String
-                element.find { |e| e.value == v }
-              when Regexp
-                element.find { |e| e.value.match(v) }
-              end
-          e ? e.set : fail(Exception::Error, "Checkbox to be set not found by value: #{v.inspect}")
-        end
-      end
-
-      # @return [Array<String>] value attributes of each checked checkbox
-      def value
-        validate_scope
-        element.find_all { |e| e.set? }.map { |e| e.value }
-      end
-
-      def options
-        validate_scope
-        element.map { |e| e.value }
-      end
-
-      # convert to LabeledGroup settable by corresponding label text
-      def to_labeled
-        LabeledGroup.new(self)
-      end
-
-      # @yield [PageObject]
-      def each(&blk)
-        validate_scope
-        super(&blk)
-      end
-
-      # @return [Array<PageObject>]
-      def to_a
-        validate_scope
-        super
-      end
+    # Acts like OptionSelectable
+    # Checkboxes collection is constrained by the same name attribute
+    # Behaves like a multi Select list.
+    # It can have none, one or more options selected
+    class CheckboxGroup < OptionSelectableGroup
 
       private
 
-      # precondition on acting on this collection
-      # @return [true] when all checkboxes in collection share the same name attribute
-      # @raise [Exception::Error] when where is more than one unique name attribute
-      # --
-      # returns true on subsequent unless magically more radios show up after initial validation
-      def validate_scope
-        return if @validated
-        groups = element.map { |e| e.name }.uniq
-        fail(Exception::Error, "CheckboxGroup definition scope too broad: Found #{groups.count} checkbox groups with names: #{groups}") unless (groups.size == 1)
-        @validated = true
+      # @api private
+      # unselects all checkboxes before setting it with desired value
+      def before_set
+        validate_scope
+        each { |o| o.set false }
       end
     end
   end

data/lib/domkey/view/label_mapper.rb

@@ -2,8 +2,9 @@ module Domkey
 
   module View
 
-    # return collection of PageObjects for label locators corresponding to id of each element in a collection
     class LabelMapper
+
+      # return collection of PageObjects for label locators corresponding to id of each element in a collection
       # @param [Array<PageObject>]
       # @param [PageObjectCollection]
       # @return [Array<PageObject>] where each PageObject is a locator for label for an id of a PageObject passed in parameters
@@ -12,6 +13,11 @@ module Domkey
           PageObject.new -> { label(for: e.element.id) }, e.container
         end
       end
+
+      # provide PageObject wrapping label corresponding to id of element in pageobject.
+      def self.find pageobject
+        PageObject.new -> { label(for: pageobject.element.id) }, pageobject.container
+      end
     end
   end
 end

data/lib/domkey/view/labeled_group.rb

@@ -16,10 +16,31 @@ module Domkey
         __setobj__(group)
       end
 
+      def before_set
+        __getobj__.set false
+      end
+
       # @param value [String] a label text to set a corresponding element referenced
       # @param value [Array<String>] one or more labels
       def set value
-        __getobj__.set false
+        before_set
+        set_strategy(value)
+      end
+
+      # @return [Array<String>] label texts for selected elements
+      def value
+        selected_ones = __getobj__.find_all { |e| e.element.set? }
+        LabelMapper.for(selected_ones).map { |e| e.element.text }
+      end
+
+      # @return [Array<String>] label texts for all elements in a group
+      def options
+        LabelMapper.for(__getobj__).map { |e| e.element.text }
+      end
+
+      private
+
+      def set_strategy value
         labels  = self.options
         indices = [*value].map do |what|
           i = case what
@@ -35,16 +56,6 @@ module Domkey
         end
       end
 
-      # @return [Array<String>] label texts for selected elements
-      def value
-        selected_ones = __getobj__.find_all { |e| e.element.set? }
-        LabelMapper.for(selected_ones).map { |e| e.element.text }
-      end
-
-      # @return [Array<String>] label texts for all elements in a group
-      def options
-        LabelMapper.for(__getobj__).map { |e| e.element.text }
-      end
     end
   end
 end

data/lib/domkey/view/option_selectable.rb

@@ -0,0 +1,102 @@
+module Domkey
+  module View
+    module OptionSelectable
+
+      # clears all options and sets only the desired value(s)
+      # @param [String, Regexp] sets default designated option by String or Regexp
+      # @param [Array<String, Regexp>] sets each String, Regexp
+      # @param [False] unselects all options
+      # @param [Hash{how => value}] selects by how strategy where how is a symbol :label, :index, :text, :value
+      # Clients need to implement individual strategy for each 'how' => 'value' pair based on what it means to be selected by what
+      def set value
+        before_set
+        set_strategy value
+      end
+
+      # @param [] opts. Represents a qualifier of what types of options to return. defaults to empty
+      # @return [Array<String>] when opts param emtpy returns array of default strings implemented by client
+      # @param [Symbol,Array<Symbol>] symbols represents what option selector to return
+      # @return [Array<Hash{what => value}] where what is a symbol for option selector, :index, :value, :text, :label
+      def value *opts
+        opts = opts.flatten
+        return value_by_default if (opts.empty? || opts.find { |e| e.kind_of?(String) })
+        value_by_options opts
+      end
+
+      # similar strategy to value but returns all options and not only selected ones
+      def options *opts
+        opts = opts.flatten
+        return options_by_default if opts.empty?
+        options_by opts
+      end
+
+      private
+
+      def options_by_default
+        fail Exception::NotImplementedError, "Subclass responsible for implementing"
+      end
+
+      def options_by opts
+        fail Exception::NotImplementedError, "Subclass responsible for implementing"
+      end
+
+      def value_by_default
+        fail Exception::NotImplementedError, "Subclass responsible for implementing"
+      end
+
+      def value_by_options options
+        fail Exception::NotImplementedError, "Subclass responsible for implementing"
+      end
+
+      def before_set
+        # hook. client can provide actions to be taken before setting this PageObject
+      end
+
+      # strategy for selecting OptionSelectable object
+      def set_strategy value
+        case value
+        when String
+          set_by_string(value)
+        when Regexp
+          set_by_regexp(value)
+        when Array
+          value.each { |v| set_strategy(v) }
+        when Hash
+          value.each_pair do |how, value|
+            case how
+            when :label
+              set_by_label(value)
+            when :text
+              set_strategy(value)
+            when :index
+              set_by_index(value)
+            when :value
+              set_by_value(value)
+            end
+          end
+        end
+      end
+
+      def set_by_string value
+        fail Exception::NotImplementedError, "Subclass responsible for implementing"
+      end
+
+      def set_by_regexp value
+        fail Exception::NotImplementedError, "Subclass responsible for implementing"
+      end
+
+      def set_by_label value
+        fail Exception::NotImplementedError, "Subclass responsible for implementing"
+      end
+
+      def set_by_index value
+        fail Exception::NotImplementedError, "Subclass responsible for implementing"
+      end
+
+      def set_by_value value
+        fail Exception::NotImplementedError, "Subclass responsible for implementing"
+      end
+
+    end
+  end
+end

data/lib/domkey/view/option_selectable_group.rb

@@ -0,0 +1,120 @@
+require 'domkey/view/option_selectable'
+require 'domkey/view/labeled_group'
+
+module Domkey
+  module View
+
+    #OptionsSelectable CheckboxGroup, RadioGroup
+    class OptionSelectableGroup < PageObjectCollection
+
+      include OptionSelectable
+
+      def set_by_index value
+        [*value].each do |i|
+          self[i.to_i].set(true)
+        end
+      end
+
+      def set_by_label value
+        to_labeled.__send__(:set_strategy, value)
+      end
+
+      def set_by_regexp value
+        o = find { |o| o.value.match(value) }
+        o ? o.element.set : fail(Exception::NotFoundError, "Element not found with value: #{v.inspect}")
+      end
+
+      def set_by_string value
+        o = find { |o| o.value == value }
+        o ? o.element.set : fail(Exception::NotFoundError, "Element not found with value: #{v.inspect}")
+      end
+
+
+      def value_by_default
+        validate_scope
+        find_all { |e| e.element.set? }.map { |e| e.value }
+      end
+
+      def value_by_options opts
+        validate_scope
+        result = []
+        each_with_index do |e, i|
+          if e.element.set?
+
+            v = opts.map do |o|
+              case o
+              when :index
+                [o, i]
+              when :label, :text
+                [o, LabelMapper.find(e).element.text]
+              else
+                [o, e.send(o)]
+              end
+            end
+            result << Hash[v]
+          end
+        end
+        result
+      end
+
+      def options_by_default
+        validate_scope
+        map { |e| e.value }
+      end
+
+      def options_by opts
+        validate_scope
+        result = []
+        each_with_index do |e, i|
+
+          v = opts.map do |o|
+            case o
+            when :index
+              [o, i]
+            when :label, :text
+              [o, LabelMapper.find(e).element.text]
+            else
+              [o, e.send(o)]
+            end
+          end
+          result << Hash[v]
+        end
+
+        result
+      end
+
+      # convert to LabeledGroup settable by corresponding label text
+      def to_labeled
+        LabeledGroup.new(self)
+      end
+
+
+      # @yield [PageObject]
+      def each(&blk)
+        validate_scope
+        super(&blk)
+      end
+
+      # @return [Array<PageObject>]
+      def to_a
+        validate_scope
+        super
+      end
+
+      private
+
+      # precondition on acting on this collection
+      # @return [true] when all radios in collection share the same name attribute
+      # @raise [Exception::Error] when where is more than one unique name attribute
+      # --
+      # returns true on subsequent unless magically more radios show up after initial validation
+      def validate_scope
+        return if @validated
+        groups = element.map { |e| e.name }.uniq
+        fail(Exception::Error, "RadioGroup definition scope too broad: Found #{groups.count} radio groups with names: #{groups}") unless (groups.size == 1)
+        @validated = true
+      end
+
+    end
+  end
+end

data/lib/domkey/view/page_object.rb

@@ -1,5 +1,5 @@
-require 'domkey/view/widgetry_package'
-require 'domkey/view/watir_widget'
+require 'domkey/view/widgetry/package'
+require 'domkey/view/widgetry/dispatcher'
 
 module Domkey
 
@@ -52,13 +52,13 @@ module Domkey
     class PageObject
 
       # @api private
-      include WidgetryPackage
+      include Widgetry::Package
 
       # Each Semantic PageObject defines what value means for itself
       # @param [SemanticValue] Delegated to WebdriverElement and we expect it to respond to set
       # @parma [Hash{Symbol => SemanticValue}]
       def set value
-        return watir_widget.set value unless value.respond_to?(:each_pair)
+        return widgetry_dispatcher.set value unless value.respond_to?(:each_pair)
         value.each_pair { |k, v| package.fetch(k).set(v) }
       end
 
@@ -68,22 +68,22 @@ module Domkey
       # @return [SemanticValue] delegated to WebdriverElement and we expect it to respond to value message
       # @return [Hash{Symbol => SemanticValue}]
       def value
-        return watir_widget.value unless package.respond_to?(:each_pair)
+        return widgetry_dispatcher.value unless package.respond_to?(:each_pair)
         Hash[package.map { |key, pageobject| [key, pageobject.value] }]
       end
 
       def options
-        return watir_widget.options unless package.respond_to?(:each_pair)
+        return widgetry_dispatcher.options unless package.respond_to?(:each_pair)
         Hash[package.map { |key, pageobject| [key, pageobject.options] }]
       end
 
       private
 
-      # wrap instantiator with strategy for setting and getting value for watir object
+      # wrap instantiator with strategy for setting and getting value for underlying object
       # expects that element to respond to set and value
-      # @returns [WatirWidget]
-      def watir_widget
-        WatirWidget.new(instantiator)
+      # @returns [Widgetry::Dispatcher] that responds to set, value, options
+      def widgetry_dispatcher
+        Widgetry.dispatcher(instantiator)
       end
 
       # @api private
@@ -96,7 +96,7 @@ module Domkey
             begin
               # peek inside suitcase that is proc. XXX ouch, ugly
               peeked_inside = package.call
-            rescue NoMethodError
+            rescue StandardError
               return package #suitecase exploded, proc returned
             end
             if peeked_inside.respond_to?(:each_pair) # hash