page_navigation 0.9 → 0.10

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 4ebc2cb244eb336736f35d2bebd8ffe53070dd32
4
- data.tar.gz: f04fc258fdb71e36343d247700258ad9da77cb40
3
+ metadata.gz: 26e978842cccf0452d958bb6a2c7efd0fc095e57
4
+ data.tar.gz: 0c3c880153a5a05a23c8e6687d3942972c14b11d
5
5
  SHA512:
6
- metadata.gz: f78f9d41851504fe576f033be34342b8d936449fd5a7460b064d353e22ecaedfbc3224391bf0c2e90928a73a1d98d72062413cd85fd66cef501a65cb4d48a124
7
- data.tar.gz: d1d31040c6989a4d0a6029caa6f450a1a0363eed048984ae2c5a41c8b0d2685d639d71efd3d575476dcefcdefe3cc63c5a27cfc54bf7ba1f02b65623499927bf
6
+ metadata.gz: b20c38f047c3d17a3fd4175b0eb5b5a6effa3f2f9459f04a0c5bbe977b87ca348b613a285f4d3be0a44d30686ad40fec39a226b6ffbcf1d4401809c3648d2ec9
7
+ data.tar.gz: 968fdf507da0d612bb1d7ed1cd4a2359bc39b10d7dd75e0f9868abf2b89ebbec61ccd030f2b8068991c2aa03be0ca48dece92dfe22ff132f771d577b5c061942
data/.gitignore CHANGED
@@ -3,6 +3,7 @@
3
3
  .bundle
4
4
  .config
5
5
  .yardoc
6
+ .idea
6
7
  Gemfile.lock
7
8
  InstalledFiles
8
9
  _yardoc
data/ChangeLog CHANGED
@@ -1,3 +1,7 @@
1
+ === Version 0.10 / 2016-10-18
2
+ * Improved error message when navigation methods are undefined
3
+ * Added optional 'visit' argument to navigate_to and navigate_all to visit first page (Thanks sciros)
4
+
1
5
  === Version 0.9 / 2013-05-03
2
6
  * Added :from entry to navigate_to method call
3
7
 
@@ -7,7 +7,7 @@ require 'data_magic'
7
7
  # that implement a PageObject like pattern.
8
8
  #
9
9
  # In order to use these two methods you must define routes. A route
10
- # is cimply an array of Class/Method calls and can contain parameters
10
+ # is simply an array of Class/Method calls and can contain parameters
11
11
  # that can be passed to the methods. Here is an example:
12
12
  #
13
13
  # @example Example routes defined in env.rb
@@ -47,22 +47,24 @@ module PageNavigation
47
47
  # page.navigate_to(PageThree) # will use the default path
48
48
  # page.navigate_to(PageThree, :using => :another_route)
49
49
  #
50
- # @param [PageObject] a class that implements the PageObject pattern.
51
- # @param [Hash] a hash that contains an element with the key
50
+ # @param [PageObject] page_cls a class that implements the PageObject pattern.
51
+ # @param [Hash] how a hash that contains two elements. One with the key
52
52
  # :using. This will be used to lookup the route. It has a
53
- # default value of :default.
54
- # @param [block] an optional block to be called
53
+ # default value of :default. The other is with the key :visit. This specifies
54
+ # whether to explicitly visit the first page. It has a default value of false.
55
+ # @param [block] block an optional block to be called
55
56
  # @return [PageObject] the page you are navigating to
56
57
  #
57
- def navigate_to(page_cls, how = {:using => :default}, &block)
58
+ def navigate_to(page_cls, how = {:using => :default, :visit => false}, &block)
58
59
  how[:using] = :default unless how[:using]
60
+ how[:visit] = false unless how[:visit]
59
61
  path = path_for how
60
62
  to_index = find_index_for(path, page_cls)-1
61
63
  if to_index == -1
62
64
  return on(page_cls, &block)
63
65
  else
64
66
  start = how[:from] ? path.find_index { |entry| entry[0] == how[:from] } : 0
65
- navigate_through_pages(path[start..to_index])
67
+ navigate_through_pages(path[start..to_index], how[:visit])
66
68
  end
67
69
  on(page_cls, &block)
68
70
  end
@@ -71,11 +73,11 @@ module PageNavigation
71
73
  # Same as navigate_to except it will start at the @current_page
72
74
  # instead the beginning of the path.
73
75
  #
74
- # @param [PageObject] a class that implements the PageObject pattern.
75
- # @param [Hash] a hash that contains an element with the key
76
+ # @param [PageObject] page_cls a class that implements the PageObject pattern.
77
+ # @param [Hash] how a hash that contains an element with the key
76
78
  # :using. This will be used to lookup the route. It has a
77
79
  # default value of :default.
78
- # @param [block] an optional block to be called
80
+ # @param [block] block an optional block to be called
79
81
  # @return [PageObject] the page you are navigating to
80
82
  #
81
83
  def continue_navigation_to(page_cls, how = {:using => :default}, &block)
@@ -83,9 +85,9 @@ module PageNavigation
83
85
  from_index = find_index_for(path, @current_page.class)
84
86
  to_index = find_index_for(path, page_cls)-1
85
87
  if from_index == to_index
86
- navigate_through_pages([path[from_index]])
88
+ navigate_through_pages([path[from_index]], false)
87
89
  else
88
- navigate_through_pages(path[from_index..to_index])
90
+ navigate_through_pages(path[from_index..to_index], false)
89
91
  end
90
92
  on(page_cls, &block)
91
93
  end
@@ -101,13 +103,14 @@ module PageNavigation
101
103
  # page.navigate_all # will use the default path
102
104
  # page.navigate_all(:using => :another_route)
103
105
  #
104
- # @param [Hash] a hash that contains an element with the key
106
+ # @param [Hash] how a hash that contains two elements. One with the key
105
107
  # :using. This will be used to lookup the route. It has a
106
- # default value of :default.
108
+ # default value of :default. The other is with the key :visit. This specifies
109
+ # whether to explicitly visit the first page. It has a default value of false.
107
110
  #
108
- def navigate_all(how = {:using => :default})
111
+ def navigate_all(how = {:using => :default, :visit => false})
109
112
  path = path_for how
110
- navigate_through_pages(path[0..-1])
113
+ navigate_through_pages(path[0..-1], how[:visit])
111
114
  end
112
115
 
113
116
  private
@@ -122,10 +125,11 @@ module PageNavigation
122
125
  path
123
126
  end
124
127
 
125
- def navigate_through_pages(pages)
128
+ def navigate_through_pages(pages, visit)
126
129
  pages.each do |cls, method, *args|
127
- page = on(cls)
128
- fail("Navigation method not specified on #{cls}.") unless page.respond_to? method
130
+ page = visit ? visit(cls) : on(cls)
131
+ visit = false # visit once, for just the first page
132
+ fail("Navigation method '#{method}' not defined on #{cls}.") unless page.respond_to? method
129
133
  page.send method unless args
130
134
  page.send method, *args if args
131
135
  end
@@ -6,7 +6,7 @@ module PageNavigation
6
6
  end
7
7
 
8
8
  def routes=(routes)
9
- raise("You must provide a :default route") unless routes[:default]
9
+ raise('You must provide a :default route') unless routes[:default]
10
10
  @routes = routes
11
11
  end
12
12
 
@@ -1,3 +1,3 @@
1
1
  module PageNavigation
2
- VERSION = "0.9"
2
+ VERSION = '0.10'
3
3
  end
@@ -4,24 +4,23 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
4
4
  require 'page_navigation/version'
5
5
 
6
6
  Gem::Specification.new do |gem|
7
- gem.name = "page_navigation"
7
+ gem.name = 'page_navigation'
8
8
  gem.version = PageNavigation::VERSION
9
9
  gem.platform = Gem::Platform::RUBY
10
- gem.authors = ["Jeffrey S. Morgan"]
11
- gem.email = ["jeff.morgan@leandog.com"]
12
- gem.homepage = "http://github.com/cheezy/page_navigation"
10
+ gem.authors = ['Jeffrey S. Morgan','Dmitry Sharkov']
11
+ gem.email = ['jeff.morgan@leandog.com']
12
+ gem.homepage = 'http://github.com/cheezy/page_navigation'
13
13
  gem.description = %q{Provides basic navigation through a collection of items that use the PageObject pattern.}
14
14
  gem.summary = %q{Provides basic navigation through a collection of items that use the PageObject pattern.}
15
15
 
16
- gem.rubyforge_project = "page_naigation"
16
+ gem.rubyforge_project = 'page_navigation'
17
17
 
18
18
  gem.files = `git ls-files`.split($/)
19
19
  gem.executables = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
20
20
  gem.test_files = gem.files.grep(%r{^(test|spec|features)/})
21
- gem.require_paths = ["lib"]
21
+ gem.require_paths = ['lib']
22
22
 
23
- gem.add_dependency 'data_magic', '>= 0.14'
23
+ gem.add_dependency 'data_magic', '>= 0.22'
24
24
 
25
- gem.add_development_dependency 'rspec', '>= 2.12.0'
26
-
25
+ gem.add_development_dependency 'rspec', '>= 3.4.0'
27
26
  end
@@ -1,22 +1,28 @@
1
1
  require 'spec_helper'
2
2
 
3
- class FactoryTestPage
3
+ class FirstPage
4
4
  end
5
5
 
6
- class AnotherPage
6
+ class MiddlePage
7
7
  end
8
8
 
9
- class YetAnotherPage
9
+ class LastPage
10
10
  end
11
11
 
12
12
  class TestNavigator
13
13
  include PageNavigation
14
14
  attr_accessor :current_page
15
15
 
16
- def on(cls)
16
+ def on(cls) #placeholder for PageFactory's on_page (alias 'on')
17
17
  cls.new
18
18
  end
19
19
 
20
+ def visit(cls) #placeholder for PageFactory's visit_page (alias 'visit')
21
+ page_instance = cls.new
22
+ page_instance.visit
23
+ page_instance
24
+ end
25
+
20
26
  def class_from_string(str)
21
27
  str.split('::').inject(Object) do |mod, class_name|
22
28
  mod.const_get(class_name)
@@ -27,137 +33,178 @@ end
27
33
  describe PageNavigation do
28
34
  before(:each) do
29
35
  @navigator = TestNavigator.new
30
- DataMagic.stub(:load)
36
+ allow(DataMagic).to receive(:load)
31
37
  end
32
38
 
33
- it "should raise an error when you do not provide a default route" do
34
- expect { TestNavigator.routes = {:another => []} }.to raise_error
39
+ it 'should raise an error when you do not provide a default route' do
40
+ expect { TestNavigator.routes = {:another => []} }.to raise_error 'You must provide a :default route'
35
41
  end
36
42
 
37
- it "should store the routes" do
38
- routes = ['a', 'b', 'c']
43
+ it 'should store the routes' do
44
+ routes = %w(a b c)
39
45
  TestNavigator.routes = {:default => routes}
40
- TestNavigator.routes[:default].should == routes
46
+ expect(TestNavigator.routes[:default]).to be routes
41
47
  end
42
48
 
43
- it "should store route data" do
49
+ it 'should store route data' do
44
50
  TestNavigator.route_data = {:default => :blah}
45
- TestNavigator.route_data.should == {:default => :blah}
51
+ expect(TestNavigator.route_data).to eq ({:default => :blah})
46
52
  end
47
53
 
48
- it "should navigate to a page calling the default methods" do
49
- pages = [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
54
+ it 'should navigate to a page calling the default methods' do
55
+ pages = [[FirstPage, :a_method], [MiddlePage, :b_method]]
50
56
  TestNavigator.routes = {:default => pages}
51
- fake_page = double('a_page')
52
- FactoryTestPage.should_receive(:new).and_return(fake_page)
53
- fake_page.should_receive(:a_method)
54
- @navigator.navigate_to(AnotherPage).class.should == AnotherPage
57
+ fake_page = double('middle_page')
58
+ expect(FirstPage).to receive(:new).and_return(fake_page)
59
+ expect(fake_page).to receive(:a_method)
60
+ expect(@navigator.navigate_to(MiddlePage).class).to be MiddlePage
55
61
  end
56
62
 
57
- it "should load the DataMagic file when specified" do
58
- pages = [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
63
+ it 'should load the DataMagic file when specified' do
64
+ pages = [[FirstPage, :a_method], [MiddlePage, :b_method]]
59
65
  TestNavigator.routes = {:default => pages}
60
66
  TestNavigator.route_data = {:default => :dm_file}
61
- fake_page = double('a_page')
62
- FactoryTestPage.should_receive(:new).and_return(fake_page)
63
- fake_page.should_receive(:a_method)
64
- DataMagic.should_receive(:load).with('dm_file.yml')
65
- @navigator.navigate_to(AnotherPage).class.should == AnotherPage
67
+ fake_page = double('middle_page')
68
+ expect(FirstPage).to receive(:new).and_return(fake_page)
69
+ expect(fake_page).to receive(:a_method)
70
+ expect(DataMagic).to receive(:load).with('dm_file.yml')
71
+ expect(@navigator.navigate_to(MiddlePage).class).to be MiddlePage
66
72
  end
67
73
 
68
- it "should pass parameters to methods when navigating" do
69
- pages = [[FactoryTestPage, :a_method, 'blah'], [AnotherPage, :b_method]]
74
+ it 'should pass parameters to methods when navigating' do
75
+ pages = [[FirstPage, :a_method, 'blah'], [MiddlePage, :b_method]]
70
76
  TestNavigator.routes = {:default => pages}
71
- fake_page = double('a_page')
72
- FactoryTestPage.should_receive(:new).and_return(fake_page)
73
- fake_page.should_receive(:a_method).with('blah')
74
- @navigator.navigate_to(AnotherPage).class.should == AnotherPage
77
+ fake_page = double('middle_page')
78
+ expect(FirstPage).to receive(:new).and_return(fake_page)
79
+ expect(fake_page).to receive(:a_method).with('blah')
80
+ expect(@navigator.navigate_to(MiddlePage).class).to be MiddlePage
75
81
  end
76
82
 
77
- it "should fail when it does not find a proper route" do
83
+ it 'should fail when it does not find a proper route' do
78
84
  TestNavigator.routes = {:default => ['a'], :another => ['b']}
79
- expect { @navigator.navigate_to(AnotherPage, :using => :no_route) }.to raise_error
85
+ expect { @navigator.navigate_to(MiddlePage, :using => :no_route) }.to raise_error
80
86
  end
81
87
 
82
- it "should fail when no default method specified" do
88
+ it 'should fail when no default method specified' do
83
89
  TestNavigator.routes = {
84
- :default => [[FactoryTestPage, :a_method], [AnotherPage, :b_method]]
90
+ :default => [[FirstPage, :a_method], [MiddlePage, :b_method]]
85
91
  }
86
- fake_page = double('a_page')
87
- FactoryTestPage.should_receive(:new).and_return(fake_page)
88
- fake_page.should_receive(:respond_to?).with(:a_method).and_return(false)
89
- expect { @navigator.navigate_to(AnotherPage) }.to raise_error
92
+ fake_page = double('middle_page')
93
+ expect(FirstPage).to receive(:new).and_return(fake_page)
94
+ expect(fake_page).to receive(:respond_to?).with(:a_method).and_return(false)
95
+ expect { @navigator.navigate_to(MiddlePage) }.to raise_error
90
96
  end
91
97
 
92
- it "should know how to continue routng from a location" do
93
- TestNavigator.routes = {
94
- :default => [[FactoryTestPage, :a_method],
95
- [AnotherPage, :b_method],
96
- [YetAnotherPage, :c_method]]
97
- }
98
- @navigator.current_page = FactoryTestPage.new
99
- f_page = FactoryTestPage.new
100
- a_page = AnotherPage.new
101
- FactoryTestPage.should_receive(:new).and_return(f_page)
102
- f_page.should_receive(:respond_to?).with(:a_method).and_return(true)
103
- f_page.should_receive(:a_method)
104
- AnotherPage.should_receive(:new).and_return(a_page)
105
- a_page.should_receive(:respond_to?).with(:b_method).and_return(true)
106
- a_page.should_receive(:b_method)
107
- @navigator.continue_navigation_to(YetAnotherPage).class.should == YetAnotherPage
108
- end
109
-
110
- it "should know how to continue routng from a location that is one page from the end" do
111
- TestNavigator.routes = {
112
- :default => [[FactoryTestPage, :a_method],
113
- [AnotherPage, :b_method],
114
- [YetAnotherPage, :c_method]]
115
- }
116
- @navigator.current_page = FactoryTestPage.new
117
- f_page = FactoryTestPage.new
118
- FactoryTestPage.should_receive(:new).and_return(f_page)
119
- f_page.should_receive(:respond_to?).with(:a_method).and_return(true)
120
- f_page.should_receive(:a_method)
121
- a_page = AnotherPage.new
122
- AnotherPage.should_receive(:new).and_return(a_page)
123
- a_page.should_receive(:respond_to?).with(:b_method).and_return(true)
124
- a_page.should_receive(:b_method)
125
- @navigator.continue_navigation_to(YetAnotherPage).class.should == YetAnotherPage
126
- end
127
-
128
- it "should know how to navigate an entire route including the last page" do
129
- TestNavigator.routes = {
130
- :default => [[FactoryTestPage, :a_method],
131
- [AnotherPage, :b_method],
132
- [YetAnotherPage, :c_method]]
133
- }
134
- f_page = FactoryTestPage.new
135
- a_page = AnotherPage.new
136
- y_page = YetAnotherPage.new
137
- FactoryTestPage.should_receive(:new).and_return(f_page)
138
- f_page.should_receive(:respond_to?).with(:a_method).and_return(true)
139
- f_page.should_receive(:a_method)
140
- AnotherPage.should_receive(:new).and_return(a_page)
141
- a_page.should_receive(:respond_to?).with(:b_method).and_return(true)
142
- a_page.should_receive(:b_method)
143
- YetAnotherPage.should_receive(:new).and_return(y_page)
144
- y_page.should_receive(:respond_to?).with(:c_method).and_return(true)
145
- y_page.should_receive(:c_method)
98
+ it 'should know how to continue routing from a location' do
99
+ first_page, middle_page, last_page = mock_common_method_calls
100
+
101
+ @navigator.current_page = FirstPage.new
102
+
103
+ expect(first_page).to receive(:a_method)
104
+ expect(middle_page).to receive(:b_method)
105
+
106
+ expect(@navigator.continue_navigation_to(LastPage).class).to be LastPage
107
+ end
108
+
109
+ it 'should know how to continue routing from a location that is one page from the end' do
110
+ first_page, middle_page, last_page = mock_common_method_calls
111
+
112
+ @navigator.current_page = MiddlePage.new
113
+
114
+ expect(first_page).not_to receive(:a_method)
115
+ expect(middle_page).to receive(:b_method)
116
+
117
+ expect(@navigator.continue_navigation_to(LastPage).class).to be LastPage
118
+ end
119
+
120
+ it 'should know how to navigate an entire route including the last page' do
121
+ first_page, middle_page, last_page = mock_common_method_calls
122
+
123
+ expect(first_page).to receive(:a_method)
124
+ expect(middle_page).to receive(:b_method)
125
+ expect(last_page).to receive(:c_method)
126
+
146
127
  @navigator.navigate_all
147
128
  end
148
129
 
149
- it "should be able to start in the middle of a route and proceed" do
150
- TestNavigator.routes = {
151
- :default => [[FactoryTestPage, :a_method],
152
- [AnotherPage, :b_method],
153
- [YetAnotherPage, :c_method]]
154
- }
155
- a_page = AnotherPage.new
156
- y_page = YetAnotherPage.new
157
- AnotherPage.should_receive(:new).and_return(a_page)
158
- a_page.should_receive(:respond_to?).with(:b_method).and_return(true)
159
- a_page.should_receive(:b_method)
160
- YetAnotherPage.should_receive(:new).and_return(y_page)
161
- @navigator.navigate_to(YetAnotherPage, :from => AnotherPage)
130
+ it 'should be able to start in the middle of a route and proceed' do
131
+ first_page, middle_page, last_page = mock_common_method_calls
132
+
133
+ expect(first_page).not_to receive(:a_method)
134
+ expect(middle_page).to receive(:b_method)
135
+
136
+ @navigator.navigate_to(LastPage, :from => MiddlePage)
137
+ end
138
+
139
+ it 'should visit page at start of route given visit param set to true' do
140
+ first_page, middle_page, last_page = mock_common_method_calls
141
+
142
+ expect(first_page).to receive(:visit)
143
+ expect(first_page).to receive(:a_method)
144
+ expect(middle_page).to receive(:b_method)
145
+ expect(middle_page).not_to receive(:visit)
146
+
147
+ @navigator.navigate_to(LastPage, visit: true)
148
+ end
149
+
150
+ it 'should not visit page at start of route given visit param set to false (explicit)' do
151
+ first_page, middle_page, last_page = mock_common_method_calls
152
+
153
+ expect(first_page).not_to receive(:visit)
154
+ expect(first_page).to receive(:a_method)
155
+ expect(middle_page).to receive(:b_method)
156
+
157
+ @navigator.navigate_to(LastPage, visit: false)
162
158
  end
159
+
160
+ it 'should not visit page at start of route given visit param set to false (default)' do
161
+ first_page, middle_page, last_page = mock_common_method_calls
162
+
163
+ expect(first_page).not_to receive(:visit)
164
+ expect(first_page).to receive(:a_method)
165
+ expect(middle_page).to receive(:b_method)
166
+
167
+ @navigator.navigate_to(LastPage)
168
+ end
169
+
170
+ it 'should handle specification of both using and visit params' do
171
+ first_page, middle_page, last_page = mock_common_method_calls
172
+
173
+ expect(first_page).to receive(:respond_to?).with(:x_method).at_least(:once).and_return(true)
174
+ expect(first_page).to receive(:visit)
175
+ expect(first_page).to receive(:x_method)
176
+ expect(middle_page).to receive(:respond_to?).with(:y_method).at_least(:once).and_return(true)
177
+ expect(middle_page).to receive(:y_method)
178
+ expect(middle_page).not_to receive(:visit)
179
+
180
+ @navigator.navigate_to(LastPage, visit: true, using: :alt)
181
+ end
182
+ end
183
+
184
+ def mock_common_method_calls
185
+ TestNavigator.routes = {
186
+ :default => [[FirstPage, :a_method],
187
+ [MiddlePage, :b_method],
188
+ [LastPage, :c_method]],
189
+ :alt => [[FirstPage, :x_method],
190
+ [MiddlePage, :y_method],
191
+ [LastPage, :z_method]]
192
+ }
193
+
194
+ first_page = FirstPage.new
195
+ allow(FirstPage).to receive(:new).and_return(first_page)
196
+ allow(first_page).to receive(:respond_to?).with(:visit).and_return(true)
197
+ allow(first_page).to receive(:respond_to?).with(:a_method).and_return(true)
198
+
199
+ middle_page = MiddlePage.new
200
+ allow(MiddlePage).to receive(:new).and_return(middle_page)
201
+ allow(middle_page).to receive(:respond_to?).with(:visit).and_return(true)
202
+ allow(middle_page).to receive(:respond_to?).with(:b_method).and_return(true)
203
+
204
+ last_page = LastPage.new
205
+ allow(LastPage).to receive(:new).and_return(last_page)
206
+ allow(last_page).to receive(:respond_to?).with(:visit).and_return(true)
207
+ allow(last_page).to receive(:respond_to?).with(:c_method).and_return(true)
208
+
209
+ return first_page, middle_page, last_page
163
210
  end
metadata CHANGED
@@ -1,43 +1,44 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: page_navigation
3
3
  version: !ruby/object:Gem::Version
4
- version: '0.9'
4
+ version: '0.10'
5
5
  platform: ruby
6
6
  authors:
7
7
  - Jeffrey S. Morgan
8
+ - Dmitry Sharkov
8
9
  autorequire:
9
10
  bindir: bin
10
11
  cert_chain: []
11
- date: 2013-05-03 00:00:00.000000000 Z
12
+ date: 2016-10-18 00:00:00.000000000 Z
12
13
  dependencies:
13
14
  - !ruby/object:Gem::Dependency
14
15
  name: data_magic
15
16
  requirement: !ruby/object:Gem::Requirement
16
17
  requirements:
17
- - - '>='
18
+ - - ">="
18
19
  - !ruby/object:Gem::Version
19
- version: '0.14'
20
+ version: '0.22'
20
21
  type: :runtime
21
22
  prerelease: false
22
23
  version_requirements: !ruby/object:Gem::Requirement
23
24
  requirements:
24
- - - '>='
25
+ - - ">="
25
26
  - !ruby/object:Gem::Version
26
- version: '0.14'
27
+ version: '0.22'
27
28
  - !ruby/object:Gem::Dependency
28
29
  name: rspec
29
30
  requirement: !ruby/object:Gem::Requirement
30
31
  requirements:
31
- - - '>='
32
+ - - ">="
32
33
  - !ruby/object:Gem::Version
33
- version: 2.12.0
34
+ version: 3.4.0
34
35
  type: :development
35
36
  prerelease: false
36
37
  version_requirements: !ruby/object:Gem::Requirement
37
38
  requirements:
38
- - - '>='
39
+ - - ">="
39
40
  - !ruby/object:Gem::Version
40
- version: 2.12.0
41
+ version: 3.4.0
41
42
  description: Provides basic navigation through a collection of items that use the
42
43
  PageObject pattern.
43
44
  email:
@@ -46,10 +47,10 @@ executables: []
46
47
  extensions: []
47
48
  extra_rdoc_files: []
48
49
  files:
49
- - .gitignore
50
- - .rspec
51
- - .ruby-gemset
52
- - .ruby-version
50
+ - ".gitignore"
51
+ - ".rspec"
52
+ - ".ruby-gemset"
53
+ - ".ruby-version"
53
54
  - ChangeLog
54
55
  - Gemfile
55
56
  - Guardfile
@@ -71,17 +72,17 @@ require_paths:
71
72
  - lib
72
73
  required_ruby_version: !ruby/object:Gem::Requirement
73
74
  requirements:
74
- - - '>='
75
+ - - ">="
75
76
  - !ruby/object:Gem::Version
76
77
  version: '0'
77
78
  required_rubygems_version: !ruby/object:Gem::Requirement
78
79
  requirements:
79
- - - '>='
80
+ - - ">="
80
81
  - !ruby/object:Gem::Version
81
82
  version: '0'
82
83
  requirements: []
83
- rubyforge_project: page_naigation
84
- rubygems_version: 2.0.0
84
+ rubyforge_project: page_navigation
85
+ rubygems_version: 2.5.1
85
86
  signing_key:
86
87
  specification_version: 4
87
88
  summary: Provides basic navigation through a collection of items that use the PageObject