autoforme 1.1.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (19) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG +4 -0
  3. data/Rakefile +15 -43
  4. data/lib/autoforme/action.rb +28 -2
  5. data/lib/autoforme/frameworks/rails.rb +7 -1
  6. data/lib/autoforme/frameworks/roda.rb +9 -3
  7. data/lib/autoforme/frameworks/sinatra.rb +10 -3
  8. data/lib/autoforme/model.rb +2 -2
  9. data/lib/autoforme/models/sequel.rb +9 -8
  10. data/lib/autoforme/version.rb +1 -1
  11. data/spec/associations_spec.rb +63 -63
  12. data/spec/basic_spec.rb +156 -146
  13. data/spec/mtm_spec.rb +67 -67
  14. data/spec/rails_spec_helper.rb +0 -9
  15. data/spec/roda_spec_helper.rb +6 -0
  16. data/spec/sequel_spec_helper.rb +0 -16
  17. data/spec/spec_helper.rb +12 -4
  18. data/spec/unit_spec.rb +178 -177
  19. metadata +59 -2
data/spec/unit_spec.rb CHANGED
@@ -14,297 +14,297 @@ describe AutoForme do
14
14
  end
15
15
 
16
16
  it "should handle table class lookup" do
17
- model.table_class_for(:browse, nil).should == 'table table-bordered table-striped'
17
+ model.table_class_for(:browse, nil).must_equal 'table table-bordered table-striped'
18
18
  framework.table_class 'foo'
19
- model.table_class_for(:browse, nil).should == 'foo'
19
+ model.table_class_for(:browse, nil).must_equal 'foo'
20
20
  framework.table_class{|mod, type, req| "#{mod.name} #{type} #{req}"}
21
- model.table_class_for(:browse, 1).should == 'Artist browse 1'
21
+ model.table_class_for(:browse, 1).must_equal 'Artist browse 1'
22
22
  model.table_class 'baz'
23
- model.table_class_for(:browse, nil).should == 'baz'
23
+ model.table_class_for(:browse, nil).must_equal 'baz'
24
24
  model.table_class{|type, req| "#{type} #{req}"}
25
- model.table_class_for(:browse, :foo).should == 'browse foo'
25
+ model.table_class_for(:browse, :foo).must_equal 'browse foo'
26
26
  end
27
27
 
28
28
  it "should handle per page lookup" do
29
- model.limit_for(:browse, nil).should == 25
29
+ model.limit_for(:browse, nil).must_equal 25
30
30
  framework.per_page 1
31
- model.limit_for(:browse, nil).should == 1
31
+ model.limit_for(:browse, nil).must_equal 1
32
32
  framework.per_page{|mod, type, req| mod.name.length + type.to_s.length + req}
33
- model.limit_for(:browse, 3).should == 15
33
+ model.limit_for(:browse, 3).must_equal 15
34
34
  model.per_page 3
35
- model.limit_for(:browse, nil).should == 3
35
+ model.limit_for(:browse, nil).must_equal 3
36
36
  model.per_page{|type, req| type.to_s.length + req}
37
- model.limit_for(:browse, -1).should == 5
37
+ model.limit_for(:browse, -1).must_equal 5
38
38
  end
39
39
 
40
40
  it "should handle columns lookup" do
41
- model.columns_for(:browse, nil).should == [:name]
41
+ model.columns_for(:browse, nil).must_equal [:name]
42
42
  framework.columns{|mod, type, req| [mod.name.to_sym, type, req]}
43
- model.columns_for(:browse, :foo).should == [:Artist, :browse, :foo]
43
+ model.columns_for(:browse, :foo).must_equal [:Artist, :browse, :foo]
44
44
  model.columns [:foo]
45
- model.columns_for(:browse, nil).should == [:foo]
45
+ model.columns_for(:browse, nil).must_equal [:foo]
46
46
  model.columns{|type, req| req ? [type] : [:foo]}
47
- model.columns_for(:browse, true).should == [:browse]
48
- model.columns_for(:browse, nil).should == [:foo]
47
+ model.columns_for(:browse, true).must_equal [:browse]
48
+ model.columns_for(:browse, nil).must_equal [:foo]
49
49
  end
50
50
 
51
51
  it "should handle column options lookup" do
52
- model.column_options_for(:show, nil, :foo).should == {:required=>false}
53
- model.column_options_for(:browse, nil, :foo).should == {}
52
+ model.column_options_for(:show, nil, :foo).must_equal(:required=>false)
53
+ model.column_options_for(:browse, nil, :foo).must_equal({})
54
54
  framework.column_options :foo=>{:as=>:textarea}
55
- model.column_options_for(:browse, :bar, :foo).should == {:as=>:textarea}
56
- model.column_options_for(:search_form, nil, :foo).should == {:required=>false}
55
+ model.column_options_for(:browse, :bar, :foo).must_equal(:as=>:textarea)
56
+ model.column_options_for(:search_form, nil, :foo).must_equal(:required=>false)
57
57
  framework.column_options :foo=>proc{|type, req| {:type=>type, :req=>req}}
58
- model.column_options_for(:browse, :bar, :foo).should == {:type=>:browse, :req=>:bar}
58
+ model.column_options_for(:browse, :bar, :foo).must_equal(:type=>:browse, :req=>:bar)
59
59
  framework.column_options{|mod, column, type, req| {mod.name.to_sym=>[type, req, column]}}
60
- model.column_options_for(:browse, :bar, :foo).should == {:Artist=>[:browse, :bar, :foo]}
60
+ model.column_options_for(:browse, :bar, :foo).must_equal(:Artist=>[:browse, :bar, :foo])
61
61
  framework.column_options{|mod, column, type, req| {5=>6}}
62
62
  model.column_options :foo=>{1=>2}
63
- model.column_options_for(:browse, nil, :foo).should == {1=>2, 5=>6}
63
+ model.column_options_for(:browse, nil, :foo).must_equal(1=>2, 5=>6)
64
64
  model.column_options :foo=>proc{|type, req| {:type=>type, :req=>req}}
65
- model.column_options_for(:browse, nil, :foo).should == {:type=>:browse, :req=>nil, 5=>6}
65
+ model.column_options_for(:browse, nil, :foo).must_equal(:type=>:browse, :req=>nil, 5=>6)
66
66
  model.column_options{|col, type, req| {:type=>type, :req=>req, :col=>col}}
67
- model.column_options_for(:browse, nil, :foo).should == {:type=>:browse, :req=>nil, :col=>:foo, 5=>6}
67
+ model.column_options_for(:browse, nil, :foo).must_equal(:type=>:browse, :req=>nil, :col=>:foo, 5=>6)
68
68
  end
69
69
 
70
70
  it "should handle order lookup" do
71
- model.order_for(:browse, nil).should == nil
71
+ model.order_for(:browse, nil).must_equal nil
72
72
  framework.order :bar
73
- model.order_for(:browse, nil).should == :bar
73
+ model.order_for(:browse, nil).must_equal :bar
74
74
  framework.order{|mod, type, req| [mod.name.to_sym, type, req]}
75
- model.order_for(:browse, :foo).should == [:Artist, :browse, :foo]
75
+ model.order_for(:browse, :foo).must_equal [:Artist, :browse, :foo]
76
76
  model.order [:foo]
77
- model.order_for(:browse, nil).should == [:foo]
77
+ model.order_for(:browse, nil).must_equal [:foo]
78
78
  model.order{|type, req| [type, req]}
79
- model.order_for(:browse, :foo).should == [:browse, :foo]
79
+ model.order_for(:browse, :foo).must_equal [:browse, :foo]
80
80
  end
81
81
 
82
82
  it "should handle eager lookup" do
83
- model.eager_for(:browse, nil).should == nil
83
+ model.eager_for(:browse, nil).must_equal nil
84
84
  model.eager [:foo]
85
- model.eager_for(:browse, nil).should == [:foo]
85
+ model.eager_for(:browse, nil).must_equal [:foo]
86
86
  model.eager{|type, req| [type, req]}
87
- model.eager_for(:browse, 1).should == [:browse, 1]
87
+ model.eager_for(:browse, 1).must_equal [:browse, 1]
88
88
  end
89
89
 
90
90
  it "should handle eager_graph lookup" do
91
- model.eager_graph_for(:browse, nil).should == nil
91
+ model.eager_graph_for(:browse, nil).must_equal nil
92
92
  model.eager_graph [:foo]
93
- model.eager_graph_for(:browse, nil).should == [:foo]
93
+ model.eager_graph_for(:browse, nil).must_equal [:foo]
94
94
  model.eager_graph{|type, req| [type, req]}
95
- model.eager_graph_for(:browse, 1).should == [:browse, 1]
95
+ model.eager_graph_for(:browse, 1).must_equal [:browse, 1]
96
96
  end
97
97
 
98
98
  it "should handle filter lookup" do
99
- model.filter_for.should == nil
99
+ model.filter_for.must_equal nil
100
100
  framework.filter{|mod| lambda{|ds, type, req| [ds, mod.name.to_sym, type, req]}}
101
- model.filter_for.call(1, :browse, 2).should == [1, :Artist, :browse, 2]
101
+ model.filter_for.call(1, :browse, 2).must_equal [1, :Artist, :browse, 2]
102
102
  model.filter{|ds, type, req| [ds, type, req]}
103
- model.filter_for.call(1, :browse, 2).should == [1, :browse, 2]
103
+ model.filter_for.call(1, :browse, 2).must_equal [1, :browse, 2]
104
104
  end
105
105
 
106
106
  it "should handle redirect lookup" do
107
- model.redirect_for.should == nil
107
+ model.redirect_for.must_equal nil
108
108
  framework.redirect{|mod| lambda{|obj, type, req| [obj, mod.name.to_sym, type, req]}}
109
- model.redirect_for.call(1, :new, 2).should == [1, :Artist, :new, 2]
109
+ model.redirect_for.call(1, :new, 2).must_equal [1, :Artist, :new, 2]
110
110
  model.redirect{|obj, type, req| [obj, type, req]}
111
- model.redirect_for.call(1, :new, 2).should == [1, :new, 2]
111
+ model.redirect_for.call(1, :new, 2).must_equal [1, :new, 2]
112
112
  end
113
113
 
114
114
  it "should handle display_name lookup" do
115
- model.display_name_for.should == nil
115
+ model.display_name_for.must_equal nil
116
116
  framework.display_name :foo
117
- model.display_name_for.should == :foo
117
+ model.display_name_for.must_equal :foo
118
118
  framework.display_name{|mod| mod.name.to_sym}
119
- model.display_name_for.should == :Artist
119
+ model.display_name_for.must_equal :Artist
120
120
 
121
121
  framework.display_name{|mod| proc{|obj, type, req| "#{obj} #{type} #{req}"}}
122
- model.object_display_name(:show, 1, :foo).should == 'foo show 1'
122
+ model.object_display_name(:show, 1, :foo).must_equal 'foo show 1'
123
123
 
124
124
  model.display_name :foo
125
- model.display_name_for.should == :foo
125
+ model.display_name_for.must_equal :foo
126
126
  model.display_name{|obj| obj.to_s}
127
- model.object_display_name(:show, nil, :foo).should == 'foo'
127
+ model.object_display_name(:show, nil, :foo).must_equal 'foo'
128
128
  model.display_name{|obj, type| "#{obj} #{type}"}
129
- model.object_display_name(:show, nil, :foo).should == 'foo show'
129
+ model.object_display_name(:show, nil, :foo).must_equal 'foo show'
130
130
  model.display_name{|obj, type, req| "#{obj} #{type} #{req}"}
131
- model.object_display_name(:show, 1, :foo).should == 'foo show 1'
131
+ model.object_display_name(:show, 1, :foo).must_equal 'foo show 1'
132
132
  end
133
133
 
134
134
  it "should handle supported_actions lookup" do
135
- model.supported_action?(:new, nil).should == true
136
- model.supported_action?(:edit, nil).should == true
137
- model.supported_action?(:search, nil).should == true
135
+ model.supported_action?(:new, nil).must_equal true
136
+ model.supported_action?(:edit, nil).must_equal true
137
+ model.supported_action?(:search, nil).must_equal true
138
138
  framework.supported_actions [:new, :search]
139
- model.supported_action?(:new, nil).should == true
140
- model.supported_action?(:edit, nil).should == false
141
- model.supported_action?(:search, nil).should == true
139
+ model.supported_action?(:new, nil).must_equal true
140
+ model.supported_action?(:edit, nil).must_equal false
141
+ model.supported_action?(:search, nil).must_equal true
142
142
  framework.supported_actions{|mod, req| req ? [:new] : []}
143
- model.supported_action?(:new, nil).should == false
144
- model.supported_action?(:new, true).should == true
143
+ model.supported_action?(:new, nil).must_equal false
144
+ model.supported_action?(:new, true).must_equal true
145
145
  model.supported_actions [:edit, :search]
146
- model.supported_action?(:new, nil).should == false
147
- model.supported_action?(:edit, nil).should == true
148
- model.supported_action?(:search, nil).should == true
146
+ model.supported_action?(:new, nil).must_equal false
147
+ model.supported_action?(:edit, nil).must_equal true
148
+ model.supported_action?(:search, nil).must_equal true
149
149
  model.supported_actions{|req| req ? [:new] : []}
150
- model.supported_action?(:new, nil).should == false
151
- model.supported_action?(:new, true).should == true
150
+ model.supported_action?(:new, nil).must_equal false
151
+ model.supported_action?(:new, true).must_equal true
152
152
  end
153
153
 
154
154
  it "should handle mtm_associations lookup" do
155
- model.supported_mtm_edit?('foos', nil).should == false
156
- model.supported_mtm_edit?('bars', nil).should == false
155
+ model.supported_mtm_edit?('foos', nil).must_equal false
156
+ model.supported_mtm_edit?('bars', nil).must_equal false
157
157
  framework.mtm_associations [:foos]
158
- model.supported_mtm_edit?('foos', nil).should == true
159
- model.supported_mtm_edit?('bars', nil).should == false
158
+ model.supported_mtm_edit?('foos', nil).must_equal true
159
+ model.supported_mtm_edit?('bars', nil).must_equal false
160
160
  framework.mtm_associations{|mod, req| req ? [:foos] : [:bars]}
161
- model.supported_mtm_edit?('foos', nil).should == false
162
- model.supported_mtm_edit?('bars', nil).should == true
163
- model.supported_mtm_edit?('foos', true).should == true
164
- model.supported_mtm_edit?('bars', true).should == false
161
+ model.supported_mtm_edit?('foos', nil).must_equal false
162
+ model.supported_mtm_edit?('bars', nil).must_equal true
163
+ model.supported_mtm_edit?('foos', true).must_equal true
164
+ model.supported_mtm_edit?('bars', true).must_equal false
165
165
  model.mtm_associations ['bars']
166
- model.supported_mtm_edit?('foos', nil).should == false
167
- model.supported_mtm_edit?('bars', nil).should == true
166
+ model.supported_mtm_edit?('foos', nil).must_equal false
167
+ model.supported_mtm_edit?('bars', nil).must_equal true
168
168
  model.mtm_associations{|req| req ? ['foos'] : ['bars']}
169
- model.supported_mtm_edit?('foos', nil).should == false
170
- model.supported_mtm_edit?('bars', nil).should == true
171
- model.supported_mtm_edit?('foos', true).should == true
172
- model.supported_mtm_edit?('bars', true).should == false
169
+ model.supported_mtm_edit?('foos', nil).must_equal false
170
+ model.supported_mtm_edit?('bars', nil).must_equal true
171
+ model.supported_mtm_edit?('foos', true).must_equal true
172
+ model.supported_mtm_edit?('bars', true).must_equal false
173
173
  end
174
174
 
175
175
  it "should handle inline_mtm_associations lookup" do
176
- model.supported_mtm_update?('foos', nil).should == false
177
- model.supported_mtm_update?('bars', nil).should == false
176
+ model.supported_mtm_update?('foos', nil).must_equal false
177
+ model.supported_mtm_update?('bars', nil).must_equal false
178
178
  framework.inline_mtm_associations [:foos]
179
- model.supported_mtm_update?('foos', nil).should == true
180
- model.supported_mtm_update?('bars', nil).should == false
179
+ model.supported_mtm_update?('foos', nil).must_equal true
180
+ model.supported_mtm_update?('bars', nil).must_equal false
181
181
  framework.inline_mtm_associations{|mod, req| req ? [:foos] : [:bars]}
182
- model.supported_mtm_update?('foos', nil).should == false
183
- model.supported_mtm_update?('bars', nil).should == true
184
- model.supported_mtm_update?('foos', true).should == true
185
- model.supported_mtm_update?('bars', true).should == false
182
+ model.supported_mtm_update?('foos', nil).must_equal false
183
+ model.supported_mtm_update?('bars', nil).must_equal true
184
+ model.supported_mtm_update?('foos', true).must_equal true
185
+ model.supported_mtm_update?('bars', true).must_equal false
186
186
  model.inline_mtm_associations ['bars']
187
- model.supported_mtm_update?('foos', nil).should == false
188
- model.supported_mtm_update?('bars', nil).should == true
187
+ model.supported_mtm_update?('foos', nil).must_equal false
188
+ model.supported_mtm_update?('bars', nil).must_equal true
189
189
  model.inline_mtm_associations{|req| req ? ['foos'] : ['bars']}
190
- model.supported_mtm_update?('foos', nil).should == false
191
- model.supported_mtm_update?('bars', nil).should == true
192
- model.supported_mtm_update?('foos', true).should == true
193
- model.supported_mtm_update?('bars', true).should == false
190
+ model.supported_mtm_update?('foos', nil).must_equal false
191
+ model.supported_mtm_update?('bars', nil).must_equal true
192
+ model.supported_mtm_update?('foos', true).must_equal true
193
+ model.supported_mtm_update?('bars', true).must_equal false
194
194
  end
195
195
 
196
196
  it "should handle association_links lookup" do
197
- model.association_links_for(:show, nil).should == []
197
+ model.association_links_for(:show, nil).must_equal []
198
198
  framework.association_links :foo
199
- model.association_links_for(:show, nil).should == [:foo]
199
+ model.association_links_for(:show, nil).must_equal [:foo]
200
200
  framework.association_links{|mod, type, req| [mod.name.to_sym, type, req]}
201
- model.association_links_for(:show, :foo).should == [:Artist, :show, :foo]
201
+ model.association_links_for(:show, :foo).must_equal [:Artist, :show, :foo]
202
202
  model.association_links [:bar]
203
- model.association_links_for(:show, nil).should == [:bar]
203
+ model.association_links_for(:show, nil).must_equal [:bar]
204
204
  model.association_links{|type, req| [type, req]}
205
- model.association_links_for(:show, :foo).should == [:show, :foo]
205
+ model.association_links_for(:show, :foo).must_equal [:show, :foo]
206
206
  end
207
207
 
208
208
  it "should handle lazy_load_association_links lookup" do
209
- model.lazy_load_association_links?(:show, nil).should == false
209
+ model.lazy_load_association_links?(:show, nil).must_equal false
210
210
  framework.lazy_load_association_links true
211
- model.lazy_load_association_links?(:show, nil).should == true
211
+ model.lazy_load_association_links?(:show, nil).must_equal true
212
212
  framework.lazy_load_association_links{|mod, type, req| req > 2}
213
- model.lazy_load_association_links?(:show, 1).should == false
214
- model.lazy_load_association_links?(:show, 3).should == true
213
+ model.lazy_load_association_links?(:show, 1).must_equal false
214
+ model.lazy_load_association_links?(:show, 3).must_equal true
215
215
  model.lazy_load_association_links false
216
- model.lazy_load_association_links?(:show, nil).should == false
216
+ model.lazy_load_association_links?(:show, nil).must_equal false
217
217
  model.lazy_load_association_links{|type, req| req > 2}
218
- model.lazy_load_association_links?(:show, 1).should == false
219
- model.lazy_load_association_links?(:show, 3).should == true
218
+ model.lazy_load_association_links?(:show, 1).must_equal false
219
+ model.lazy_load_association_links?(:show, 3).must_equal true
220
220
  end
221
221
 
222
222
  it "should handle form_attributes lookup" do
223
- model.form_attributes_for(:show, nil).should == {}
223
+ model.form_attributes_for(:show, nil).must_equal({})
224
224
  framework.form_attributes :class=>'foo'
225
- model.form_attributes_for(:show, nil).should == {:class=>'foo'}
225
+ model.form_attributes_for(:show, nil).must_equal(:class=>'foo')
226
226
  framework.form_attributes{|mod, type, req| {:class=>"#{mod} #{type} #{req}"}}
227
- model.form_attributes_for(:show, 1).should == {:class=>'Artist show 1'}
227
+ model.form_attributes_for(:show, 1).must_equal(:class=>'Artist show 1')
228
228
 
229
229
  framework.form_attributes :class=>'foo'
230
230
  model.form_attributes :data=>"bar"
231
- model.form_attributes_for(:show, nil).should == {:class=>'foo', :data=>'bar'}
231
+ model.form_attributes_for(:show, nil).must_equal(:class=>'foo', :data=>'bar')
232
232
  model.form_attributes{|type, req| {:data=>"#{type} #{req}"}}
233
- model.form_attributes_for(:show, 1).should == {:class=>'foo', :data=>'show 1'}
233
+ model.form_attributes_for(:show, 1).must_equal(:class=>'foo', :data=>'show 1')
234
234
  end
235
235
 
236
236
  it "should handle form_options lookup" do
237
- model.form_options_for(:show, nil).should == {}
237
+ model.form_options_for(:show, nil).must_equal({})
238
238
  framework.form_options :class=>'foo'
239
- model.form_options_for(:show, nil).should == {:class=>'foo'}
239
+ model.form_options_for(:show, nil).must_equal(:class=>'foo')
240
240
  framework.form_options{|mod, type, req| {:class=>"#{mod} #{type} #{req}"}}
241
- model.form_options_for(:show, 1).should == {:class=>'Artist show 1'}
241
+ model.form_options_for(:show, 1).must_equal(:class=>'Artist show 1')
242
242
 
243
243
  framework.form_options :class=>'foo'
244
244
  model.form_options :data=>"bar"
245
- model.form_options_for(:show, nil).should == {:class=>'foo', :data=>'bar'}
245
+ model.form_options_for(:show, nil).must_equal(:class=>'foo', :data=>'bar')
246
246
  model.form_options{|type, req| {:data=>"#{type} #{req}"}}
247
- model.form_options_for(:show, 1).should == {:class=>'foo', :data=>'show 1'}
247
+ model.form_options_for(:show, 1).must_equal(:class=>'foo', :data=>'show 1')
248
248
  end
249
249
 
250
250
  it "should handle page_header lookup" do
251
- model.page_header_for(:show, nil).should be_nil
251
+ model.page_header_for(:show, nil).must_equal nil
252
252
  framework.page_header "foo"
253
- model.page_header_for(:show, nil).should == 'foo'
253
+ model.page_header_for(:show, nil).must_equal 'foo'
254
254
  framework.page_header{|mod, type, req| "#{mod} #{type} #{req}"}
255
- model.page_header_for(:show, 1).should == 'Artist show 1'
255
+ model.page_header_for(:show, 1).must_equal 'Artist show 1'
256
256
  model.page_header "bar"
257
- model.page_header_for(:show, nil).should == 'bar'
257
+ model.page_header_for(:show, nil).must_equal 'bar'
258
258
  model.page_header{|type, req| "#{type} #{req}"}
259
- model.page_header_for(:show, 1).should == 'show 1'
259
+ model.page_header_for(:show, 1).must_equal 'show 1'
260
260
  end
261
261
 
262
262
  it "should handle page_footer lookup" do
263
- model.page_footer_for(:show, nil).should be_nil
263
+ model.page_footer_for(:show, nil).must_equal nil
264
264
  framework.page_footer "foo"
265
- model.page_footer_for(:show, nil).should == 'foo'
265
+ model.page_footer_for(:show, nil).must_equal 'foo'
266
266
  framework.page_footer{|mod, type, req| "#{mod} #{type} #{req}"}
267
- model.page_footer_for(:show, 1).should == 'Artist show 1'
267
+ model.page_footer_for(:show, 1).must_equal 'Artist show 1'
268
268
  model.page_footer "bar"
269
- model.page_footer_for(:show, nil).should == 'bar'
269
+ model.page_footer_for(:show, nil).must_equal 'bar'
270
270
  model.page_footer{|type, req| "#{type} #{req}"}
271
- model.page_footer_for(:show, 1).should == 'show 1'
271
+ model.page_footer_for(:show, 1).must_equal 'show 1'
272
272
  end
273
273
 
274
274
  it "should handle autocompletion options" do
275
275
  model.autocomplete_options({})
276
- model.autocomplete(:type=>:show, :query=>'foo').should == []
276
+ model.autocomplete(:type=>:show, :query=>'foo').must_equal []
277
277
  a = Artist.create(:name=>'FooBar')
278
- model.autocomplete(:type=>:show, :query=>'foo').should == ["#{a.id} - FooBar"]
279
- model.autocomplete(:type=>:show, :query=>'boo').should == []
278
+ model.autocomplete(:type=>:show, :query=>'foo').must_equal ["#{a.id} - FooBar"]
279
+ model.autocomplete(:type=>:show, :query=>'boo').must_equal []
280
280
  b = Artist.create(:name=>'BooFar')
281
- model.autocomplete(:type=>:show, :query=>'boo').should == ["#{b.id} - BooFar"]
282
- model.autocomplete(:type=>:show, :query=>'oo').sort.should == ["#{a.id} - FooBar", "#{b.id} - BooFar"]
281
+ model.autocomplete(:type=>:show, :query=>'boo').must_equal ["#{b.id} - BooFar"]
282
+ model.autocomplete(:type=>:show, :query=>'oo').sort.must_equal ["#{a.id} - FooBar", "#{b.id} - BooFar"]
283
283
 
284
284
  framework.autocomplete_options :display=>:id
285
- model.autocomplete(:type=>:show, :query=>a.id.to_s).should == ["#{a.id} - #{a.id}"]
285
+ model.autocomplete(:type=>:show, :query=>a.id.to_s).must_equal ["#{a.id} - #{a.id}"]
286
286
  framework.autocomplete_options{|mod, type, req| {:limit=>req}}
287
- model.autocomplete(:type=>:show, :query=>'oo', :request=>1).should == ["#{a.id} - FooBar"]
287
+ model.autocomplete(:type=>:show, :query=>'oo', :request=>1).must_equal ["#{a.id} - FooBar"]
288
288
  model.autocomplete_options :display=>:id
289
- model.autocomplete(:type=>:show, :query=>a.id.to_s).should == ["#{a.id} - #{a.id}"]
289
+ model.autocomplete(:type=>:show, :query=>a.id.to_s).must_equal ["#{a.id} - #{a.id}"]
290
290
 
291
291
  framework.autocomplete_options({})
292
- model.autocomplete(:type=>:show, :query=>a.id.to_s).should == ["#{a.id} - #{a.id}"]
292
+ model.autocomplete(:type=>:show, :query=>a.id.to_s).must_equal ["#{a.id} - #{a.id}"]
293
293
  model.autocomplete_options :display=>proc{:id}
294
- model.autocomplete(:type=>:show, :query=>b.id.to_s).should == ["#{b.id} - #{b.id}"]
294
+ model.autocomplete(:type=>:show, :query=>b.id.to_s).must_equal ["#{b.id} - #{b.id}"]
295
295
  model.autocomplete_options :limit=>1
296
- model.autocomplete(:type=>:show, :query=>'oo').should == ["#{a.id} - FooBar"]
296
+ model.autocomplete(:type=>:show, :query=>'oo').must_equal ["#{a.id} - FooBar"]
297
297
  model.autocomplete_options :limit=>proc{1}
298
- model.autocomplete(:type=>:show, :query=>'oo').should == ["#{a.id} - FooBar"]
298
+ model.autocomplete(:type=>:show, :query=>'oo').must_equal ["#{a.id} - FooBar"]
299
299
  model.autocomplete_options :callback=>proc{|ds, opts| ds.reverse_order(:id)}
300
- model.autocomplete(:type=>:show, :query=>'oo').should == ["#{b.id} - BooFar", "#{a.id} - FooBar"]
300
+ model.autocomplete(:type=>:show, :query=>'oo').must_equal ["#{b.id} - BooFar", "#{a.id} - FooBar"]
301
301
 
302
302
  model.autocomplete_options :filter=>proc{|ds, opts| ds.where(:name=>opts[:query])}
303
- model.autocomplete(:type=>:show, :query=>'foo').should == []
304
- model.autocomplete(:type=>:show, :query=>'FooBar').should == ["#{a.id} - FooBar"]
303
+ model.autocomplete(:type=>:show, :query=>'foo').must_equal []
304
+ model.autocomplete(:type=>:show, :query=>'FooBar').must_equal ["#{a.id} - FooBar"]
305
305
 
306
306
  model.autocomplete_options{|type, req| {:limit=>req}}
307
- model.autocomplete(:type=>:show, :query=>'oo', :request=>1).should == ["#{a.id} - FooBar"]
307
+ model.autocomplete(:type=>:show, :query=>'oo', :request=>1).must_equal ["#{a.id} - FooBar"]
308
308
  end
309
309
  end
310
310
 
@@ -332,27 +332,27 @@ describe AutoForme do
332
332
  end
333
333
 
334
334
  artist.autocomplete_options({})
335
- model.autocomplete(:query=>'foo', :association=>:artist).should == []
335
+ model.autocomplete(:query=>'foo', :association=>:artist).must_equal []
336
336
  a = Artist.create(:name=>'FooBar')
337
- model.autocomplete(:query=>'foo', :association=>:artist).should == ["#{a.id} - FooBar"]
338
- model.autocomplete(:query=>'boo', :association=>:artist).should == []
337
+ model.autocomplete(:query=>'foo', :association=>:artist).must_equal ["#{a.id} - FooBar"]
338
+ model.autocomplete(:query=>'boo', :association=>:artist).must_equal []
339
339
  b = Artist.create(:name=>'BooFar')
340
- model.autocomplete(:query=>'boo', :association=>:artist).should == ["#{b.id} - BooFar"]
341
- model.autocomplete(:query=>'oo', :association=>:artist).sort.should == ["#{a.id} - FooBar", "#{b.id} - BooFar"]
340
+ model.autocomplete(:query=>'boo', :association=>:artist).must_equal ["#{b.id} - BooFar"]
341
+ model.autocomplete(:query=>'oo', :association=>:artist).sort.must_equal ["#{a.id} - FooBar", "#{b.id} - BooFar"]
342
342
  artist.autocomplete_options :display=>:id
343
- model.autocomplete(:query=>a.id.to_s, :association=>:artist).should == ["#{a.id} - #{a.id}"]
343
+ model.autocomplete(:query=>a.id.to_s, :association=>:artist).must_equal ["#{a.id} - #{a.id}"]
344
344
  artist.autocomplete_options :display=>proc{:id}
345
- model.autocomplete(:query=>b.id.to_s, :association=>:artist).should == ["#{b.id} - #{b.id}"]
345
+ model.autocomplete(:query=>b.id.to_s, :association=>:artist).must_equal ["#{b.id} - #{b.id}"]
346
346
  artist.autocomplete_options :limit=>1
347
- model.autocomplete(:query=>'oo', :association=>:artist).should == ["#{a.id} - FooBar"]
347
+ model.autocomplete(:query=>'oo', :association=>:artist).must_equal ["#{a.id} - FooBar"]
348
348
  artist.autocomplete_options :limit=>proc{1}
349
- model.autocomplete(:query=>'oo', :association=>:artist).should == ["#{a.id} - FooBar"]
349
+ model.autocomplete(:query=>'oo', :association=>:artist).must_equal ["#{a.id} - FooBar"]
350
350
  artist.autocomplete_options :callback=>proc{|ds, opts| ds.reverse_order(:id)}
351
- model.autocomplete(:query=>'oo', :association=>:artist).should == ["#{b.id} - BooFar", "#{a.id} - FooBar"]
351
+ model.autocomplete(:query=>'oo', :association=>:artist).must_equal ["#{b.id} - BooFar", "#{a.id} - FooBar"]
352
352
 
353
353
  artist.autocomplete_options :filter=>proc{|ds, opts| ds.where(:name=>opts[:query])}
354
- model.autocomplete(:query=>'foo', :association=>:artist).should == []
355
- model.autocomplete(:query=>'FooBar', :association=>:artist).should == ["#{a.id} - FooBar"]
354
+ model.autocomplete(:query=>'foo', :association=>:artist).must_equal []
355
+ model.autocomplete(:query=>'FooBar', :association=>:artist).must_equal ["#{a.id} - FooBar"]
356
356
  end
357
357
  end
358
358
 
@@ -379,36 +379,36 @@ describe AutoForme do
379
379
  end
380
380
 
381
381
  artist.autocomplete_options({})
382
- model.autocomplete(:query=>'foo', :association=>:artists).should == []
382
+ model.autocomplete(:query=>'foo', :association=>:artists).must_equal []
383
383
  a = Artist.create(:name=>'FooBar')
384
- model.autocomplete(:query=>'foo', :association=>:artists).should == ["#{a.id} - FooBar"]
385
- model.autocomplete(:query=>'boo', :association=>:artists).should == []
384
+ model.autocomplete(:query=>'foo', :association=>:artists).must_equal ["#{a.id} - FooBar"]
385
+ model.autocomplete(:query=>'boo', :association=>:artists).must_equal []
386
386
  b = Artist.create(:name=>'BooFar')
387
- model.autocomplete(:query=>'boo', :association=>:artists).should == ["#{b.id} - BooFar"]
388
- model.autocomplete(:query=>'oo', :association=>:artists).sort.should == ["#{a.id} - FooBar", "#{b.id} - BooFar"]
387
+ model.autocomplete(:query=>'boo', :association=>:artists).must_equal ["#{b.id} - BooFar"]
388
+ model.autocomplete(:query=>'oo', :association=>:artists).sort.must_equal ["#{a.id} - FooBar", "#{b.id} - BooFar"]
389
389
  c = Album.create(:name=>'Quux')
390
390
  c.add_artist(a)
391
- model.autocomplete(:query=>'oo', :association=>:artists, :exclude=>c.id).sort.should == ["#{b.id} - BooFar"]
391
+ model.autocomplete(:query=>'oo', :association=>:artists, :exclude=>c.id).sort.must_equal ["#{b.id} - BooFar"]
392
392
  artist.autocomplete_options :display=>:id
393
- model.autocomplete(:query=>a.id.to_s, :association=>:artists).should == ["#{a.id} - #{a.id}"]
394
- model.autocomplete(:query=>b.id.to_s, :association=>:artists, :exclude=>c.id).should == ["#{b.id} - #{b.id}"]
393
+ model.autocomplete(:query=>a.id.to_s, :association=>:artists).must_equal ["#{a.id} - #{a.id}"]
394
+ model.autocomplete(:query=>b.id.to_s, :association=>:artists, :exclude=>c.id).must_equal ["#{b.id} - #{b.id}"]
395
395
  artist.autocomplete_options :display=>proc{:id}
396
- model.autocomplete(:query=>b.id.to_s, :association=>:artists).should == ["#{b.id} - #{b.id}"]
397
- model.autocomplete(:query=>a.id.to_s, :association=>:artists, :exclude=>c.id).should == []
396
+ model.autocomplete(:query=>b.id.to_s, :association=>:artists).must_equal ["#{b.id} - #{b.id}"]
397
+ model.autocomplete(:query=>a.id.to_s, :association=>:artists, :exclude=>c.id).must_equal []
398
398
  artist.autocomplete_options :limit=>1
399
- model.autocomplete(:query=>'oo', :association=>:artists).should == ["#{a.id} - FooBar"]
400
- model.autocomplete(:query=>'oo', :association=>:artists, :exclude=>c.id).should == ["#{b.id} - BooFar"]
399
+ model.autocomplete(:query=>'oo', :association=>:artists).must_equal ["#{a.id} - FooBar"]
400
+ model.autocomplete(:query=>'oo', :association=>:artists, :exclude=>c.id).must_equal ["#{b.id} - BooFar"]
401
401
  artist.autocomplete_options :limit=>proc{1}
402
- model.autocomplete(:query=>'oo', :association=>:artists).should == ["#{a.id} - FooBar"]
403
- model.autocomplete(:query=>'oo', :association=>:artists, :exclude=>c.id).should == ["#{b.id} - BooFar"]
402
+ model.autocomplete(:query=>'oo', :association=>:artists).must_equal ["#{a.id} - FooBar"]
403
+ model.autocomplete(:query=>'oo', :association=>:artists, :exclude=>c.id).must_equal ["#{b.id} - BooFar"]
404
404
  artist.autocomplete_options :callback=>proc{|ds, opts| ds.reverse_order(:id)}
405
- model.autocomplete(:query=>'oo', :association=>:artists).should == ["#{b.id} - BooFar", "#{a.id} - FooBar"]
406
- model.autocomplete(:query=>'oo', :association=>:artists, :exclude=>c.id).should == ["#{b.id} - BooFar"]
405
+ model.autocomplete(:query=>'oo', :association=>:artists).must_equal ["#{b.id} - BooFar", "#{a.id} - FooBar"]
406
+ model.autocomplete(:query=>'oo', :association=>:artists, :exclude=>c.id).must_equal ["#{b.id} - BooFar"]
407
407
 
408
408
  artist.autocomplete_options :filter=>proc{|ds, opts| ds.where(:name=>opts[:query])}
409
- model.autocomplete(:query=>'foo', :association=>:artists).should == []
410
- model.autocomplete(:query=>'FooBar', :association=>:artists).should == ["#{a.id} - FooBar"]
411
- model.autocomplete(:query=>'FooBar', :association=>:artists, :exclude=>c.id).should == []
409
+ model.autocomplete(:query=>'foo', :association=>:artists).must_equal []
410
+ model.autocomplete(:query=>'FooBar', :association=>:artists).must_equal ["#{a.id} - FooBar"]
411
+ model.autocomplete(:query=>'FooBar', :association=>:artists, :exclude=>c.id).must_equal []
412
412
  end
413
413
  end
414
414
 
@@ -425,25 +425,26 @@ describe AutoForme::OptsAttributes do
425
425
  end
426
426
 
427
427
  it "should act as a getter if given no arguments, and setter if given arguments or a block" do
428
- @o.foo.should be_nil
429
- @o.foo(1).should == 1
430
- @o.foo.should == 1
428
+ @o.foo.must_equal nil
429
+ @o.foo(1).must_equal 1
430
+ @o.foo.must_equal 1
431
431
  p = proc{}
432
- @o.foo(&p).should == p
433
- @o.foo.should == p
432
+ # Work around minitest bug
433
+ assert_equal @o.foo(&p), p
434
+ assert_equal @o.foo, p
434
435
  end
435
436
 
436
437
  it "should should raise an error if given more than one argument" do
437
- proc{@o.foo(1, 2)}.should raise_error(ArgumentError)
438
+ proc{@o.foo(1, 2)}.must_raise(ArgumentError)
438
439
  end
439
440
 
440
441
  it "should should raise an error if given block and argument" do
441
- proc{@o.foo(1){}}.should raise_error(ArgumentError)
442
+ proc{@o.foo(1){}}.must_raise(ArgumentError)
442
443
  end
443
444
  end
444
445
 
445
446
  describe AutoForme do
446
447
  it ".version should return a typical version string" do
447
- AutoForme.version.should =~ /\A\d+\.\d+\.\d+\z/
448
+ AutoForme.version.must_match /\A\d+\.\d+\.\d+\z/
448
449
  end
449
450
  end