watirsome 0.1.3 → 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d8dd7d5de4e6d3bd01e4b28482988d65963424d1
+  data.tar.gz: fb3b3abc789fdb5237609ae41b98d035a31ab6d2
+SHA512:
+  metadata.gz: fc8eca156fa9928d4c1dd6644cda72e0749d3981e682e96ac3cf499e1853839935fa170f2750b7217c16498ec03252cc55fd6d91e9d627934dea6f0b3dbed492
+  data.tar.gz: 5ef5a76cc02b4c4d64230431871ae1c7c11cccf22787db111b862697417d7a7db176554e56343725ac2199db5738cf015895748b722e900f63629b27e8f2316a

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+#### v0.1.4
+
+* Support element subtype boolean locators (e.g. `select_list :list, selected: 'Default'`)
+
 #### v0.1.3
 
 * Remove `Watirsome.region_matcher` so now any module may implement `initialize_region`.

data/README.md

@@ -79,22 +79,24 @@ page.svg_element   # equals to @browser.element(tag_name: 'svg')
 page.login_button  # equals to @browser.button(class: 'submit', index: 1)
 ```
 
-Watirsome also provides you with opportunity to locate elements by using any boolean method Watir element supports.
+Watirsome also provides you with opportunity to locate elements by using any boolean method Watir element (and subelements) supports.
 
 ```ruby
 class Page
   include Watirsome
 
   div :layer, class: 'layer', visible: true
-  span :wrapper, class: 'span', exists: false
+  span :wrapper, exists: false
+  select_list :country, selected: 'Please select country...'
 end
 
 page = Page.new(@browser)
-page.layer_div     # equals to @browser.divs(class: 'layer').find { |e| e.visible? == true }
-page.wrapper_span  # equals to @browser.divs(class: 'layer').find { |e| e.exists? == false }
+page.layer_div           # equals to @browser.divs(class: 'layer').find { |e| e.visible? == true }
+page.wrapper_span        # equals to @browser.spans.find { |e| e.exists? == false }
+page.country_select_list # equals to @browser.select_lists.find { |e| e.selected?('Please select country...') }
 ```
 
-You can also use proc/lambda/block to locate element. Block is executed in the context of initalized page, so other accessors can be used.
+You can also use proc/lambda/block to locate element. Block is executed in the context of initialized page, so other accessors can be used.
 
 ```ruby
 class Page
@@ -145,17 +147,17 @@ page.svg_element          #=> #<Watir::HTMLElement:0x15288276ab771162 selector={
 
 #### Readable accessors
 
-For each redable element, accessor method is defined which returns text of that element.
+For each readable element, accessor method is defined which returns text of that element.
 
 Read accessor method name is `element_name`.
 
-Default redable methods are: `[:div, :span, :p, :h1, :h2, :h3, :h4, :h5, :h6, :select_list, :text_field, :textarea]`.
+Default readable methods are: `[:div, :span, :p, :h1, :h2, :h3, :h4, :h5, :h6, :select_list, :text_field, :textarea]`.
 
-You can make other elements redable by adding tag names to `Watirsome.redable`.
+You can make other elements readable by adding tag names to `Watirsome.readable`.
 
 ```ruby
-# make section redable
-Watirsome.redable << :section
+# make section readable
+Watirsome.readable << :section
 
 class Page
   include Watirsome

data/lib/watirsome/accessors.rb

@@ -52,7 +52,7 @@ module Watirsome
       # @api private
       #
       def define_element_accessor(name, method, *args, &block)
-        watir_args, custom_args = extract_custom_args(args)
+        watir_args, custom_args = extract_custom_args(method, args)
         define_method :"#{name}_#{method}" do |*opts|
           if block_given?
             instance_exec(*opts, &block)
@@ -73,7 +73,7 @@ module Watirsome
       # @api private
       #
       def define_click_accessor(name, method, *args, &block)
-        watir_args, custom_args = extract_custom_args(args)
+        watir_args, custom_args = extract_custom_args(method, args)
         define_method name do |*opts|
           if block_given?
             instance_exec(*opts, &block).click
@@ -98,7 +98,7 @@ module Watirsome
       # @api private
       #
       def define_read_accessor(name, method, *args, &block)
-        watir_args, custom_args = extract_custom_args(args)
+        watir_args, custom_args = extract_custom_args(method, args)
         define_method name do |*opts|
           element = if block_given?
                       instance_exec(*opts, &block)
@@ -129,7 +129,7 @@ module Watirsome
       # @api private
       #
       def define_set_accessor(name, method, *args, &block)
-        watir_args, custom_args = extract_custom_args(args)
+        watir_args, custom_args = extract_custom_args(method, args)
         define_method :"#{name}=" do |*opts|
           element = if block_given?
                       instance_exec(&block)
@@ -157,7 +157,7 @@ module Watirsome
       # @api private
       #
       def define_select_accessor(name, method, *args, &block)
-        watir_args, custom_args = extract_custom_args(args)
+        watir_args, custom_args = extract_custom_args(method, args)
         define_method :"#{name}=" do |*opts|
           if block_given?
             instance_exec(&block).select *opts
@@ -171,18 +171,19 @@ module Watirsome
       # Extracts custom arguments which Watirsome gracefully handles from
       # mixed array with Watir locators.
       #
+      # @param [Symbol, String] method
       # @param [Array] args
       # @return Two arrays: Watir locators and custom locators
       # @api private
       #
-      def extract_custom_args(*args)
+      def extract_custom_args(method, *args)
         identifier = args.shift
         watir_args, custom_args = [], []
         identifier.each_with_index do |hashes, index|
           watir_arg, custom_arg = {}, {}
           if hashes && !hashes.is_a?(Proc)
             hashes.each do |k, v|
-              if Watir::Element.instance_methods.include? :"#{k}?"
+              if Watir.element_class_for(method).instance_methods.include? :"#{k}?"
                 custom_arg[k] = identifier[index][k]
               else
                 watir_arg[k] = v
@@ -218,7 +219,15 @@ module Watirsome
           plural = Watirsome.plural?(method)
           method = Watirsome.pluralize(method) unless plural
           elements = @browser.send(method, *watir_args)
-          custom_args.first.each { |k, v| elements.to_a.select! { |e| e.send(:"#{k}?") == v } }
+          custom_args.first.each do |k, v|
+            elements.to_a.select! do |e|
+              if e.method(:"#{k}?").arity == 0
+                s.send(:"#{k}?") == v
+              else
+                e.send(:"#{k}?", v)
+              end
+            end
+          end
           plural ? elements : elements.first
         end
       end

data/lib/watirsome/version.rb

@@ -1,3 +1,3 @@
 module Watirsome
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end # Watirsome

data/spec/lib/watirsome/accessors_spec.rb

@@ -3,10 +3,18 @@ require 'spec_helper'
 describe Watirsome::Accessors do
   include_context :page
   include_context :element
-  
+
   it_defines :element_accessor, %w(div a text_field select_list)
   it_defines :read_accessor,    %w(div text_field select_list)
   it_defines :click_accessor,   %w(a)
   it_defines :set_accessor,     %w(text_field checkbox)
   it_defines :select_accessor,  %w(select_list)
+
+  it 'supports subtype custom locators' do
+    element2 = double('element')
+    expect(watir).to receive(:select_lists).with(id: 'select_list').and_return([element, element2])
+    expect(element).to receive(:selected?).with('Test').and_return(true)
+    expect(element2).to receive(:selected?).with('Test').and_return(false)
+    expect(page.select_list8_select_list).to eq(element)
+  end
 end

data/spec/lib/watirsome/initializers_spec.rb

@@ -7,32 +7,32 @@ describe Watirsome::Initializers do
     it 'does not initalize page if there is no constructor defined' do
       page = Page.dup
       page.class_eval { remove_method :initialize_page }
-      page.should_not_receive :initialize_page
+      expect(page).not_to receive(:initialize_page)
       page.new(watir)
     end
 
     it 'initializes page if there is constructor defined' do
-      page.instance_variable_get(:@initialized).should == true
+      expect(page.instance_variable_get(:@initialized)).to eq(true)
     end
 
     it 'initalizes regions' do
-      Page.any_instance.should_receive :initialize_regions
+      expect_any_instance_of(Page).to receive(:initialize_regions)
       Page.new(watir)
     end
   end
 
   describe '#initialize_regions' do
     it 'initalizes included regions' do
-      page.instance_variable_get(:@included_initialized).should == 1
+      expect(page.instance_variable_get(:@included_initialized)).to eq(1)
     end
 
     it 'initalizes extended regions' do
-      page.instance_variable_get(:@extended_initialized).should == 1
+      expect(page.instance_variable_get(:@extended_initialized)).to eq(1)
     end
 
     it 'caches initalized regions' do
       page.initialize_regions
-      page.instance_variable_get(:@included_initialized).should == 1
+      expect(page.instance_variable_get(:@included_initialized)).to eq(1)
     end
   end
 end

data/spec/lib/watirsome_spec.rb

@@ -5,15 +5,15 @@ describe Watirsome do
     describe ".#{method}" do
       it 'returns array of accessors' do
         accessors = described_class.send(method)
-        accessors.should be_an(Array)
+        expect(accessors).to be_an(Array)
         accessors.each do |accessor|
-          accessor.should be_a(Symbol)
+          expect(accessor).to be_a(Symbol)
         end
       end
 
       it 'allows to add custom accessors' do
         described_class.send(method) << :custom
-        described_class.send(method).should include(:custom)
+        expect(described_class.send(method)).to include(:custom)
       end
     end
 
@@ -28,11 +28,11 @@ describe Watirsome do
       end
 
       it "returns true if element is #{method}" do
-        described_class.send(:"#{method}?", tag).should == true
+        expect(described_class.send(:"#{method}?", tag)).to eq(true)
       end
 
       it "returns false if element is not #{method}" do
-        described_class.send(:"#{method}?", :foo).should == false
+        expect(described_class.send(:"#{method}?", :foo)).to eq(false)
       end
     end
   end
@@ -40,50 +40,50 @@ describe Watirsome do
   describe '.watir_methods' do
     it 'returns array of watir container methods' do
       described_class.watir_methods.each do |method|
-        Watir::Container.instance_methods.should include(method)
+        expect(Watir::Container.instance_methods).to include(method)
       end
     end
   end
 
   describe '.watirsome?' do
     it 'returns true if method is watir-contained' do
-      described_class.watirsome?(:div).should == true
+      expect(described_class.watirsome?(:div)).to eq(true)
     end
 
     it 'returns false if method is not watir-contained' do
-      described_class.watirsome?(:foo).should == false
+      expect(described_class.watirsome?(:foo)).to eq(false)
     end
   end
 
   describe '.plural?' do
     it 'returns true if watir-contained method is plural with "s" ending' do
-      described_class.plural?(:divs).should == true
+      expect(described_class.plural?(:divs)).to eq(true)
     end
 
     it 'returns true if watir-contained method is plural with "es" ending' do
-      described_class.plural?(:checkboxes).should == true
+      expect(described_class.plural?(:checkboxes)).to eq(true)
     end
 
     it 'returns false if watir-contained method is singular' do
-      described_class.plural?(:div).should == false
+      expect(described_class.plural?(:div)).to eq(false)
     end
 
     it 'returns false if method is not watir-contained' do
-      described_class.plural?(:foo).should == false
+      expect(described_class.plural?(:foo)).to eq(false)
     end
   end
 
   describe '.pluralize' do
     it 'pluralizes method name with "s"' do
-      described_class.pluralize(:div).should == :divs
+      expect(described_class.pluralize(:div)).to eq(:divs)
     end
 
     it 'pluralizes method name with "es"' do
-      described_class.pluralize(:checkbox).should == :checkboxes
+      expect(described_class.pluralize(:checkbox)).to eq(:checkboxes)
     end
 
     it 'raises error when cannot pluralizes method' do
-      -> { described_class.pluralize(:foo) }.should raise_error(Watirsome::Errors::CannotPluralizeError)
+      expect { described_class.pluralize(:foo) }.to raise_error(Watirsome::Errors::CannotPluralizeError)
     end
   end
 
@@ -91,19 +91,19 @@ describe Watirsome do
     include_context :page
 
     it 'adds accessor class methods' do
-      page.class.should respond_to(:div)
+      expect(page.class).to respond_to(:div)
     end
 
     it 'does not add #extract_selector' do
-      page.class.should_not respond_to(:extract_selector)
+      expect(page.class).not_to respond_to(:extract_selector)
     end
 
     it 'adds accessor instance methods' do
-      page.private_methods.should include(:grab_elements)
+      expect(page.private_methods).to include(:grab_elements)
     end
 
     it 'adds regions initializer' do
-      page.should respond_to(:initialize_regions)
+      expect(page).to respond_to(:initialize_regions)
     end
   end
 end

data/spec/spec_helper.rb

@@ -6,8 +6,8 @@ SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   Coveralls::SimpleCov::Formatter
 ]
 SimpleCov.start do
-  add_filter "/spec/" 
-  add_filter "/vendor/" 
+  add_filter "/spec/"
+  add_filter "/vendor/"
 end
 
 require 'watir-webdriver'
@@ -19,13 +19,13 @@ end
 
 RSpec.configure do |spec|
   spec.alias_it_should_behave_like_to :it_defines, 'it defines'
-  
+
   shared_context :page do
-    let(:watir) { stub('watir')    }
-    let(:page)  { Page.new(watir)  }
+    let(:watir) { double('watir') }
+    let(:page)  { Page.new(watir) }
   end
-  
+
   shared_context :element do
-    let(:element) { stub('element', visible?: true) }
+    let(:element) { double('element', visible?: true) }
   end
 end

data/spec/support/page.rb

@@ -40,10 +40,13 @@ class Page
     # set/select accessor cannot have block arguments
     case tag
     when 'div', 'a'
-      send(tag, :"#{tag}7") { |id| @browser.send(tag, id: id) }    
+      send(tag, :"#{tag}7") { |id| @browser.send(tag, id: id) }
     when 'text_field', 'select_list'
-      send(tag, :"#{tag}7") { @browser.send(tag, id: tag) }    
+      send(tag, :"#{tag}7") { @browser.send(tag, id: tag) }
     end
   end
 
+  # custom subtype locators
+  select_list :select_list8, id: 'select_list', selected: 'Test'
+
 end # Page

data/spec/support/shared_examples/click_accessor.rb

@@ -1,51 +1,51 @@
 shared_examples_for :click_accessor do |tags|
   tags.each do |tag|
-    context tag do 
+    context tag do
       def accessor(tag, index, *args)
         page.send :"#{tag}#{index}", *args
       end
 
       it 'clicks element with no locators' do
-        watir.should_receive(tag).with(no_args).and_return(element)
-        element.should_receive(:click).with(any_args)
+        expect(watir).to receive(tag).with(no_args).and_return(element)
+        expect(element).to receive(:click).with(any_args)
         accessor(tag, 1)
       end
 
       it 'clicks element with single watir locator' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:click).with(any_args)
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:click).with(any_args)
         accessor(tag, 2)
       end
 
       it 'clicks element with multiple watir locator' do
-        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
-        element.should_receive(:click).with(any_args)
+        expect(watir).to receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        expect(element).to receive(:click).with(any_args)
         accessor(tag, 3)
       end
 
       it 'clicks element with custom locator' do
-        element2 = stub('element', visible?: false)
+        element2 = double('element', visible?: false)
         plural = Watirsome.pluralize(tag)
-        watir.should_receive(plural).with(id: tag, class: tag).and_return([element, element2])
-        element.should_receive(:click).with(any_args)
+        expect(watir).to receive(plural).with(id: tag, class: tag).and_return([element, element2])
+        expect(element).to receive(:click).with(any_args)
         accessor(tag, 4)
       end
 
       it 'clicks element with proc' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:click).with(any_args)
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:click).with(any_args)
         accessor(tag, 5)
       end
 
       it 'clicks element with lambda' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:click).with(any_args)
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:click).with(any_args)
         accessor(tag, 6)
       end
 
       it 'clicks element with block and custom arguments' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:click).with(any_args)
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:click).with(any_args)
         accessor(tag, 7, tag)
       end
     end

data/spec/support/shared_examples/element_accessor.rb

@@ -1,47 +1,47 @@
 shared_examples_for :element_accessor do |tags|
   tags.each do |tag|
-    context tag do 
+    context tag do
       def accessor(tag, index, *args)
         page.send :"#{tag}#{index}_#{tag}", *args
       end
 
       it 'finds element with no locators' do
-        watir.should_receive(tag).with(no_args).and_return(element)
-        accessor(tag, 1).should == element
+        expect(watir).to receive(tag).with(no_args).and_return(element)
+        expect(accessor(tag, 1)).to eq(element)
       end
 
       it 'finds element with single watir locator' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        accessor(tag, 2).should == element
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(accessor(tag, 2)).to eq(element)
       end
 
       it 'finds element with multiple watir locator' do
-        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
-        accessor(tag, 3).should == element
+        expect(watir).to receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        expect(accessor(tag, 3)).to eq(element)
       end
 
       it 'finds element with custom locator' do
-        element2 = stub('element')
+        element2 = double('element')
         plural = Watirsome.pluralize(tag)
-        watir.should_receive(plural).with(id: tag, class: tag).and_return([element, element2])
-        element.should_receive(:visible?).with(no_args).and_return(true)
-        element2.should_receive(:visible?).with(no_args).and_return(false)
-        accessor(tag, 4).should == element
+        expect(watir).to receive(plural).with(id: tag, class: tag).and_return([element, element2])
+        expect(element).to receive(:visible?).and_return(true)
+        expect(element2).to receive(:visible?).and_return(false)
+        expect(accessor(tag, 4)).to eq(element)
       end
 
       it 'finds element with proc' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        accessor(tag, 5).should == element
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(accessor(tag, 5)).to eq(element)
       end
 
       it 'finds element with lambda' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        accessor(tag, 6).should == element
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(accessor(tag, 6)).to eq(element)
       end
 
       it 'finds element with block and custom arguments' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        accessor(tag, 7, tag).should == element
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(accessor(tag, 7, tag)).to eq(element)
       end
     end
   end

data/spec/support/shared_examples/read_accessor.rb

@@ -1,67 +1,67 @@
 shared_examples_for :read_accessor do |tags|
   tags.each do |tag|
-    context tag do 
+    context tag do
       def accessor(tag, index, *args)
         page.send :"#{tag}#{index}", *args
       end
-      
+
       def read_expectation(tag)
         case tag
         when 'text_field'
-          element.should_receive(:value).and_return('text')  
+          expect(element).to receive(:value).and_return('text')
         when 'select_list'
-          option1 = stub('option1', selected?: true)
-          option2 = stub('option2', selected?: false)
-          element.should_receive(:options).and_return([option1, option2])
-          option1.should_receive(:text).and_return('text')
-          option2.should_not_receive(:text)
+          option1 = double('option1', selected?: true)
+          option2 = double('option2', selected?: false)
+          expect(element).to receive(:options).and_return([option1, option2])
+          expect(option1).to receive(:text).and_return('text')
+          expect(option2).not_to receive(:text)
         else
-          element.should_receive(:text).and_return('text')  
+          expect(element).to receive(:text).and_return('text')
         end
       end
 
       it 'gets text from element with no locators' do
-        watir.should_receive(tag).with(no_args).and_return(element)
+        expect(watir).to receive(tag).with(no_args).and_return(element)
         read_expectation(tag)
-        accessor(tag, 1).should == 'text'
+        expect(accessor(tag, 1)).to eq('text')
       end
 
       it 'gets text from element with single watir locator' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
         read_expectation(tag)
-        accessor(tag, 2).should == 'text'
+        expect(accessor(tag, 2)).to eq('text')
       end
 
       it 'gets text from element with multiple watir locator' do
-        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        expect(watir).to receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
         read_expectation(tag)
-        accessor(tag, 3).should == 'text'
+        expect(accessor(tag, 3)).to eq('text')
       end
 
       it 'gets text from element with custom locator' do
-        element2 = stub('element', visible?: false)
+        element2 = double('element', visible?: false)
         plural = Watirsome.pluralize(tag)
-        watir.should_receive(plural).with(id: tag, class: tag).and_return([element, element2])
+        expect(watir).to receive(plural).with(id: tag, class: tag).and_return([element, element2])
         read_expectation(tag)
-        accessor(tag, 4).should == 'text'
+        expect(accessor(tag, 4)).to eq('text')
       end
 
       it 'gets text from element with proc' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
         read_expectation(tag)
-        accessor(tag, 5).should == 'text'
+        expect(accessor(tag, 5)).to eq('text')
       end
 
       it 'gets text from element with lambda' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
         read_expectation(tag)
-        accessor(tag, 6).should == 'text'
+        expect(accessor(tag, 6)).to eq('text')
       end
 
       it 'gets text from element with block and custom arguments' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
         read_expectation(tag)
-        accessor(tag, 7, tag).should == 'text'
+        expect(accessor(tag, 7, tag)).to eq('text')
       end
     end
   end

data/spec/support/shared_examples/select_accessor.rb

@@ -1,45 +1,45 @@
 shared_examples_for :select_accessor do |tags|
   tags.each do |tag|
-    context tag do 
+    context tag do
       def accessor(tag, index, *args)
         page.send :"#{tag}#{index}=", *args
       end
 
       it 'selects option for element with no locators' do
-        watir.should_receive(tag).with(no_args).and_return(element)
-        element.should_receive(:select).with('value')
+        expect(watir).to receive(tag).with(no_args).and_return(element)
+        expect(element).to receive(:select).with('value')
         accessor(tag, 1, 'value')
       end
 
       it 'selects option for element with single watir locator' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:select).with('value')
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:select).with('value')
         accessor(tag, 2, 'value')
       end
 
       it 'selects option for element with multiple watir locator' do
-        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
-        element.should_receive(:select).with('value')
+        expect(watir).to receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        expect(element).to receive(:select).with('value')
         accessor(tag, 3, 'value')
       end
 
       it 'selects option for element with custom locator' do
-        element2 = stub('element', visible?: false)
+        element2 = double('element', visible?: false)
         plural = Watirsome.pluralize(tag)
-        watir.should_receive(plural).with(id: tag, class: tag).and_return([element, element2])
-        element.should_receive(:select).with('value')
+        expect(watir).to receive(plural).with(id: tag, class: tag).and_return([element, element2])
+        expect(element).to receive(:select).with('value')
         accessor(tag, 4, 'value')
       end
 
       it 'selects option for element with proc' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:select).with('value')
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:select).with('value')
         accessor(tag, 5, 'value')
       end
 
       it 'selects option for element with lambda' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:select).with('value')
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:select).with('value')
         accessor(tag, 6, 'value')
       end
     end

data/spec/support/shared_examples/set_accessor.rb

@@ -1,52 +1,52 @@
 shared_examples_for :set_accessor do |tags|
   tags.each do |tag|
-    context tag do 
+    context tag do
       def accessor(tag, index, *args)
         page.send :"#{tag}#{index}=", *args
       end
 
       it 'sets value on element with no locators' do
-        watir.should_receive(tag).with(no_args).and_return(element)
-        element.should_receive(:set).with('value')
+        expect(watir).to receive(tag).with(no_args).and_return(element)
+        expect(element).to receive(:set).with('value')
         accessor(tag, 1, 'value')
       end
 
       it 'sets value on element with single watir locator' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:set).with('value')
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:set).with('value')
         accessor(tag, 2, 'value')
       end
 
       it 'sets value on element with multiple watir locator' do
-        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
-        element.should_receive(:set).with('value')
+        expect(watir).to receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        expect(element).to receive(:set).with('value')
         accessor(tag, 3, 'value')
       end
 
       it 'sets value on element with custom locator' do
-        element2 = stub('element', visible?: false)
+        element2 = double('element', visible?: false)
         plural = Watirsome.pluralize(tag)
-        watir.should_receive(plural).with(id: tag, class: tag).and_return([element, element2])
-        element.should_receive(:set).with('value')
+        expect(watir).to receive(plural).with(id: tag, class: tag).and_return([element, element2])
+        expect(element).to receive(:set).with('value')
         accessor(tag, 4, 'value')
       end
 
       it 'sets value on element with proc' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:set).with('value')
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:set).with('value')
         accessor(tag, 5, 'value')
       end
 
       it 'sets value on element with lambda' do
-        watir.should_receive(tag).with(id: tag).and_return(element)
-        element.should_receive(:set).with('value')
+        expect(watir).to receive(tag).with(id: tag).and_return(element)
+        expect(element).to receive(:set).with('value')
         accessor(tag, 6, 'value')
       end
-      
+
       it 'sends keys if element cannot be set' do
-        watir.should_receive(tag).with(no_args).and_return(element)
-        element.stub(:respond_to?).with(:set).and_return(false)
-        element.should_receive(:send_keys).with('value')
+        expect(watir).to receive(tag).with(no_args).and_return(element)
+        allow(element).to receive(:respond_to?).with(:set).and_return(false)
+        expect(element).to receive(:send_keys).with('value')
         accessor(tag, 1, 'value')
       end
     end

data/watirsome.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = %w(lib)
 
-  s.add_dependency 'watir-webdriver'
+  s.add_dependency 'watir-webdriver', '>= 0.6.9'
 
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'rake'

metadata

@@ -1,110 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: watirsome
 version: !ruby/object:Gem::Version
-  version: 0.1.3
-  prerelease: 
+  version: 0.1.4
 platform: ruby
 authors:
 - Alex Rodionov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-22 00:00:00.000000000 Z
+date: 2014-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: watir-webdriver
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.6.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.6.9
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: fuubar
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Pure dynamic Watir-based page object DSL
@@ -113,8 +100,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .coveralls.yml
-- .travis.yml
+- ".coveralls.yml"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.md
@@ -139,33 +126,26 @@ files:
 - watirsome.gemspec
 homepage: http://github.com/p0deje/watirsome
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2091343636029663572
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 2091343636029663572
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Awesome page objects with Watir
 test_files:
 - spec/lib/watirsome/accessors_spec.rb