citeproc-ruby 1.0.3 → 1.0.4

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 (22) hide show
  1. checksums.yaml +4 -4
  2. data/Gemfile +1 -1
  3. data/features/renderer.feature +2 -2
  4. data/features/step_definitions/renderer.rb +7 -7
  5. data/features/support/env.rb +1 -1
  6. data/lib/citeproc/ruby/format.rb +7 -13
  7. data/lib/citeproc/ruby/version.rb +1 -1
  8. data/spec/citeproc/ruby/engine_spec.rb +16 -16
  9. data/spec/citeproc/ruby/formats/default_spec.rb +43 -43
  10. data/spec/citeproc/ruby/formats/html_spec.rb +24 -24
  11. data/spec/citeproc/ruby/renderer/choose_spec.rb +59 -59
  12. data/spec/citeproc/ruby/renderer/date_spec.rb +23 -23
  13. data/spec/citeproc/ruby/renderer/group_spec.rb +10 -10
  14. data/spec/citeproc/ruby/renderer/history_spec.rb +8 -8
  15. data/spec/citeproc/ruby/renderer/label_spec.rb +31 -31
  16. data/spec/citeproc/ruby/renderer/layout_spec.rb +3 -3
  17. data/spec/citeproc/ruby/renderer/macro_spec.rb +2 -2
  18. data/spec/citeproc/ruby/renderer/names_spec.rb +76 -76
  19. data/spec/citeproc/ruby/renderer/number_spec.rb +13 -13
  20. data/spec/citeproc/ruby/renderer/text_spec.rb +17 -17
  21. data/spec/citeproc/ruby/renderer_spec.rb +32 -32
  22. metadata +12 -12
data/spec/citeproc/ruby/renderer/choose_spec.rb CHANGED
@@ -15,7 +15,7 @@ module CiteProc
15
15
  let(:node) { CSL::Style::Choose.new }
16
16
 
17
17
  it 'returns an empty string by default' do
18
- renderer.render(item, node).should == ''
18
+ expect(renderer.render(item, node)).to eq('')
19
19
  end
20
20
 
21
21
  describe 'when there is a single nested block' do
@@ -30,12 +30,12 @@ module CiteProc
30
30
  it 'returns the content of the nested node when the condition evaluates' do
31
31
  block[:variable] = 'issue'
32
32
  item.data[:issue] = 1
33
- renderer.render(item, node).should == 'retrieved'
33
+ expect(renderer.render(item, node)).to eq('retrieved')
34
34
  end
35
35
 
36
36
  it 'returns an empty string when the condition does not hold' do
37
37
  block[:variable] = 'issue'
38
- renderer.render(item, node).should == ''
38
+ expect(renderer.render(item, node)).to eq('')
39
39
  end
40
40
  end
41
41
  end
@@ -44,14 +44,14 @@ module CiteProc
44
44
  let(:node) { CSL::Style::Choose::Block.new }
45
45
 
46
46
  it 'returns an empty string by default' do
47
- renderer.render(item, node).should == ''
47
+ expect(renderer.render(item, node)).to eq('')
48
48
  end
49
49
 
50
50
  describe 'when there is a text node in the block' do
51
51
  before(:each) { node << CSL::Style::Text.new( :term => 'retrieved') }
52
52
 
53
53
  it 'returns the content of the nested node when there is no condition' do
54
- renderer.render(item, node).should == 'retrieved'
54
+ expect(renderer.render(item, node)).to eq('retrieved')
55
55
  end
56
56
  end
57
57
  end
@@ -60,38 +60,38 @@ module CiteProc
60
60
  let(:node) { CSL::Style::Choose::Block.new }
61
61
 
62
62
  it 'returns true by default (else block)' do
63
- renderer.evaluates?(item, node).should be_true
63
+ expect(renderer.evaluates?(item, node)).to be_truthy
64
64
  end
65
65
 
66
66
  it 'fails if there is an unknown condition type' do
67
- node.stub(:conditions).and_return([[:unknown, :all?, 'x']])
68
- lambda { renderer.evaluates?(item, node) }.should raise_error
67
+ allow(node).to receive(:conditions).and_return([[:unknown, :all?, 'x']])
68
+ expect { renderer.evaluates?(item, node) }.to raise_error
69
69
  end
70
70
 
71
71
  it 'returns false for disambiguate (implementation pending)' do
72
72
  node[:disambiguate] = true
73
- renderer.evaluates?(item, node).should be_false
73
+ expect(renderer.evaluates?(item, node)).to be_falsey
74
74
  end
75
75
 
76
76
  it 'returns false for position (implementation pending)' do
77
77
  node[:position] = 'first'
78
- renderer.evaluates?(item, node).should be_false
78
+ expect(renderer.evaluates?(item, node)).to be_falsey
79
79
  end
80
80
 
81
81
  describe 'for is-numeric conditions' do
82
82
  before { node[:'is-numeric'] = 'note archive' }
83
83
 
84
84
  it 'returns false unless all variables are numeric' do
85
- renderer.evaluates?(item, node).should be_false
85
+ expect(renderer.evaluates?(item, node)).to be_falsey
86
86
 
87
87
  item.data[:archive] = 1
88
- renderer.evaluates?(item, node).should be_false
88
+ expect(renderer.evaluates?(item, node)).to be_falsey
89
89
 
90
90
  item.data[:note] = 'L2d'
91
- renderer.evaluates?(item, node).should be_true
91
+ expect(renderer.evaluates?(item, node)).to be_truthy
92
92
 
93
93
  item.data[:archive] = 'second'
94
- renderer.evaluates?(item, node).should be_false
94
+ expect(renderer.evaluates?(item, node)).to be_falsey
95
95
  end
96
96
  end
97
97
 
@@ -99,13 +99,13 @@ module CiteProc
99
99
  before { node[:'is-uncertain-date'] = 'issued' }
100
100
 
101
101
  it 'returns false unless all variables contain uncertain dates' do
102
- renderer.evaluates?(item, node).should be_false
102
+ expect(renderer.evaluates?(item, node)).to be_falsey
103
103
 
104
104
  item.data[:issued] = 2012
105
- renderer.evaluates?(item, node).should be_false
105
+ expect(renderer.evaluates?(item, node)).to be_falsey
106
106
 
107
107
  item.data[:issued].uncertain!
108
- renderer.evaluates?(item, node).should be_true
108
+ expect(renderer.evaluates?(item, node)).to be_truthy
109
109
  end
110
110
  end
111
111
 
@@ -113,40 +113,40 @@ module CiteProc
113
113
  before { node[:locator] = 'figure book sub-verbo' }
114
114
 
115
115
  it 'returns false unless the locator matches all of the given locators' do
116
- renderer.evaluates?(item, node).should be_false
116
+ expect(renderer.evaluates?(item, node)).to be_falsey
117
117
 
118
118
  item.locator = :book
119
- renderer.evaluates?(item, node).should be_false
119
+ expect(renderer.evaluates?(item, node)).to be_falsey
120
120
 
121
121
  item.locator = 'volume'
122
- renderer.evaluates?(item, node).should be_false
122
+ expect(renderer.evaluates?(item, node)).to be_falsey
123
123
 
124
124
  item.locator = 'figure'
125
- renderer.evaluates?(item, node).should be_false
125
+ expect(renderer.evaluates?(item, node)).to be_falsey
126
126
  end
127
127
 
128
128
  describe 'when the match attribute is set to "any"' do
129
129
  before { node[:match] = 'any' }
130
130
 
131
131
  it 'returns false unless the locator matches any of the given locators' do
132
- renderer.evaluates?(item, node).should be_false
132
+ expect(renderer.evaluates?(item, node)).to be_falsey
133
133
 
134
134
  item.locator = :book
135
- renderer.evaluates?(item, node).should be_true
135
+ expect(renderer.evaluates?(item, node)).to be_truthy
136
136
 
137
137
  item.locator = 'volume'
138
- renderer.evaluates?(item, node).should be_false
138
+ expect(renderer.evaluates?(item, node)).to be_falsey
139
139
 
140
140
  item.locator = 'figure'
141
- renderer.evaluates?(item, node).should be_true
141
+ expect(renderer.evaluates?(item, node)).to be_truthy
142
142
  end
143
143
 
144
144
  it 'matches "sub verbo" as "sub-verbo"' do
145
145
  item.locator = 'sub-verbo'
146
- renderer.evaluates?(item, node).should be_true
146
+ expect(renderer.evaluates?(item, node)).to be_truthy
147
147
 
148
148
  item.locator = 'sub verbo'
149
- renderer.evaluates?(item, node).should be_true
149
+ expect(renderer.evaluates?(item, node)).to be_truthy
150
150
  end
151
151
  end
152
152
  end
@@ -155,32 +155,32 @@ module CiteProc
155
155
  before { node[:type] = 'book treaty' }
156
156
 
157
157
  it 'returns false unless the type matches all of the given types' do
158
- renderer.evaluates?(item, node).should be_false
158
+ expect(renderer.evaluates?(item, node)).to be_falsey
159
159
 
160
160
  item.data[:type] = :book
161
- renderer.evaluates?(item, node).should be_false
161
+ expect(renderer.evaluates?(item, node)).to be_falsey
162
162
 
163
163
  item.data[:type] = 'article'
164
- renderer.evaluates?(item, node).should be_false
164
+ expect(renderer.evaluates?(item, node)).to be_falsey
165
165
 
166
166
  item.data[:type] = 'treaty'
167
- renderer.evaluates?(item, node).should be_false
167
+ expect(renderer.evaluates?(item, node)).to be_falsey
168
168
  end
169
169
 
170
170
  describe 'when the match attribute is set to "any"' do
171
171
  before { node[:match] = 'any' }
172
172
 
173
173
  it 'returns false unless the locator matches any of the given locators' do
174
- renderer.evaluates?(item, node).should be_false
174
+ expect(renderer.evaluates?(item, node)).to be_falsey
175
175
 
176
176
  item.data[:type] = :book
177
- renderer.evaluates?(item, node).should be_true
177
+ expect(renderer.evaluates?(item, node)).to be_truthy
178
178
 
179
179
  item.data[:type] = 'article'
180
- renderer.evaluates?(item, node).should be_false
180
+ expect(renderer.evaluates?(item, node)).to be_falsey
181
181
 
182
182
  item.data[:type] = 'treaty'
183
- renderer.evaluates?(item, node).should be_true
183
+ expect(renderer.evaluates?(item, node)).to be_truthy
184
184
  end
185
185
  end
186
186
  end
@@ -189,32 +189,32 @@ module CiteProc
189
189
  before { node[:variable] = 'volume issue' }
190
190
 
191
191
  it 'returns false unless the item has all variables' do
192
- renderer.evaluates?(item, node).should be_false
192
+ expect(renderer.evaluates?(item, node)).to be_falsey
193
193
 
194
194
  item.data[:volume] = 1
195
- renderer.evaluates?(item, node).should be_false
195
+ expect(renderer.evaluates?(item, node)).to be_falsey
196
196
 
197
197
  item.data[:issue] = 1
198
- renderer.evaluates?(item, node).should be_true
198
+ expect(renderer.evaluates?(item, node)).to be_truthy
199
199
 
200
200
  item.data[:volume] = nil
201
- renderer.evaluates?(item, node).should be_false
201
+ expect(renderer.evaluates?(item, node)).to be_falsey
202
202
  end
203
203
 
204
204
  describe 'with internal negations' do
205
205
  before { node[:variable] = 'volume not:issue' }
206
206
 
207
207
  it 'returns false unless the item has (or does not have) all variables' do
208
- renderer.evaluates?(item, node).should be_false
208
+ expect(renderer.evaluates?(item, node)).to be_falsey
209
209
 
210
210
  item.data[:volume] = 1
211
- renderer.evaluates?(item, node).should be_true
211
+ expect(renderer.evaluates?(item, node)).to be_truthy
212
212
 
213
213
  item.data[:issue] = 1
214
- renderer.evaluates?(item, node).should be_false
214
+ expect(renderer.evaluates?(item, node)).to be_falsey
215
215
 
216
216
  item.data[:volume] = nil
217
- renderer.evaluates?(item, node).should be_false
217
+ expect(renderer.evaluates?(item, node)).to be_falsey
218
218
  end
219
219
  end
220
220
 
@@ -222,32 +222,32 @@ module CiteProc
222
222
  before { node[:match] = 'any' }
223
223
 
224
224
  it 'returns false unless the item has any of the variables' do
225
- renderer.evaluates?(item, node).should be_false
225
+ expect(renderer.evaluates?(item, node)).to be_falsey
226
226
 
227
227
  item.data[:volume] = 1
228
- renderer.evaluates?(item, node).should be_true
228
+ expect(renderer.evaluates?(item, node)).to be_truthy
229
229
 
230
230
  item.data[:issue] = 1
231
- renderer.evaluates?(item, node).should be_true
231
+ expect(renderer.evaluates?(item, node)).to be_truthy
232
232
 
233
233
  item.data[:volume] = nil
234
- renderer.evaluates?(item, node).should be_true
234
+ expect(renderer.evaluates?(item, node)).to be_truthy
235
235
  end
236
236
 
237
237
  describe 'with internal negations' do
238
238
  before { node[:variable] = 'volume not:issue' }
239
239
 
240
240
  it 'returns false unless the item has (or does not have) any of the variables' do
241
- renderer.evaluates?(item, node).should be_true
241
+ expect(renderer.evaluates?(item, node)).to be_truthy
242
242
 
243
243
  item.data[:volume] = 1
244
- renderer.evaluates?(item, node).should be_true
244
+ expect(renderer.evaluates?(item, node)).to be_truthy
245
245
 
246
246
  item.data[:issue] = 1
247
- renderer.evaluates?(item, node).should be_true
247
+ expect(renderer.evaluates?(item, node)).to be_truthy
248
248
 
249
249
  item.data[:volume] = nil
250
- renderer.evaluates?(item, node).should be_false
250
+ expect(renderer.evaluates?(item, node)).to be_falsey
251
251
  end
252
252
  end
253
253
  end
@@ -256,32 +256,32 @@ module CiteProc
256
256
  before { node[:match] = 'none' }
257
257
 
258
258
  it 'returns false unless the item has none of the variables' do
259
- renderer.evaluates?(item, node).should be_true
259
+ expect(renderer.evaluates?(item, node)).to be_truthy
260
260
 
261
261
  item.data[:volume] = 1
262
- renderer.evaluates?(item, node).should be_false
262
+ expect(renderer.evaluates?(item, node)).to be_falsey
263
263
 
264
264
  item.data[:issue] = 1
265
- renderer.evaluates?(item, node).should be_false
265
+ expect(renderer.evaluates?(item, node)).to be_falsey
266
266
 
267
267
  item.data[:volume] = nil
268
- renderer.evaluates?(item, node).should be_false
268
+ expect(renderer.evaluates?(item, node)).to be_falsey
269
269
  end
270
270
 
271
271
  describe 'with internal negations' do
272
272
  before { node[:variable] = 'volume not:issue' }
273
273
 
274
274
  it 'returns false unless the item has (or does not have) none of the variables' do
275
- renderer.evaluates?(item, node).should be_false
275
+ expect(renderer.evaluates?(item, node)).to be_falsey
276
276
 
277
277
  item.data[:volume] = 1
278
- renderer.evaluates?(item, node).should be_false
278
+ expect(renderer.evaluates?(item, node)).to be_falsey
279
279
 
280
280
  item.data[:issue] = 1
281
- renderer.evaluates?(item, node).should be_false
281
+ expect(renderer.evaluates?(item, node)).to be_falsey
282
282
 
283
283
  item.data[:volume] = nil
284
- renderer.evaluates?(item, node).should be_true
284
+ expect(renderer.evaluates?(item, node)).to be_truthy
285
285
  end
286
286
  end
287
287
  end
data/spec/citeproc/ruby/renderer/date_spec.rb CHANGED
@@ -19,7 +19,7 @@ module CiteProc
19
19
  before(:each) { item.data[:issued] = '2012-01-27' }
20
20
 
21
21
  it "uses the locale's date parts to render the date" do
22
- renderer.render(item, node).should == '01/27/2012'
22
+ expect(renderer.render(item, node)).to eq('01/27/2012')
23
23
  end
24
24
  end
25
25
  end
@@ -31,39 +31,39 @@ module CiteProc
31
31
  before(:each) { item.data[:issued] = '2012-01-27' }
32
32
 
33
33
  it 'returns an empty string by default' do
34
- renderer.render_date(item, node).should == ''
34
+ expect(renderer.render_date(item, node)).to eq('')
35
35
  end
36
36
 
37
37
  describe 'and given a node with a year part' do
38
38
  before(:each) { node << CSL::Style::DatePart.new(:name => 'year') }
39
39
 
40
40
  it 'returns the year as "2012"' do
41
- renderer.render_date(item, node).should == '2012'
41
+ expect(renderer.render_date(item, node)).to eq('2012')
42
42
  end
43
43
 
44
44
  describe 'and a day part' do
45
45
  before(:each) { node << CSL::Style::DatePart.new(:name => 'day') }
46
46
 
47
47
  it 'returns "201227"' do
48
- renderer.render_date(item, node).should == '201227'
48
+ expect(renderer.render_date(item, node)).to eq('201227')
49
49
  end
50
50
 
51
51
  it 'applies delimiters when set on the node' do
52
52
  node[:delimiter] = '/'
53
- renderer.render_date(item, node).should == '2012/27'
53
+ expect(renderer.render_date(item, node)).to eq('2012/27')
54
54
  end
55
55
 
56
56
  describe 'and a month part' do
57
57
  before(:each) { node << CSL::Style::DatePart.new(:name => 'month') }
58
58
 
59
59
  it 'returns "201227January"' do
60
- renderer.render_date(item, node).should == '201227January'
60
+ expect(renderer.render_date(item, node)).to eq('201227January')
61
61
  end
62
62
 
63
63
  it 'returns "2012/27/01" when the month form set to "numeric-leading-zeros" and the node has a delimiter "/"' do
64
64
  node.parts.last[:form] = 'numeric-leading-zeros'
65
65
  node[:delimiter] = '/'
66
- renderer.render_date(item, node).should == '2012/27/01'
66
+ expect(renderer.render_date(item, node)).to eq('2012/27/01')
67
67
  end
68
68
  end
69
69
  end
@@ -84,25 +84,25 @@ module CiteProc
84
84
  let(:independence) { CiteProc::Date.new([1776, 7, 4]) }
85
85
 
86
86
  it 'returns an empty string by default' do
87
- renderer.render_date_part(CiteProc::Date.today, node).should == ''
87
+ expect(renderer.render_date_part(CiteProc::Date.today, node)).to eq('')
88
88
  end
89
89
 
90
90
  describe 'when the name is set to "day"' do
91
91
  before(:each) { node[:name] = 'day' }
92
92
 
93
93
  it 'renders the day as number by default' do
94
- renderer.render_date_part(today, node).should == today.day.to_s
94
+ expect(renderer.render_date_part(today, node)).to eq(today.day.to_s)
95
95
  end
96
96
 
97
97
  it 'renders the day as an ordinal number when the form is set to "ordinal"' do
98
98
  node[:form] = 'ordinal'
99
- renderer.render_date_part(independence, node).should == '4th'
99
+ expect(renderer.render_date_part(independence, node)).to eq('4th')
100
100
 
101
101
  renderer.locale.limit_day_ordinals!
102
- renderer.render_date_part(independence, node).should == '4'
102
+ expect(renderer.render_date_part(independence, node)).to eq('4')
103
103
 
104
104
  independence.day = 1
105
- renderer.render_date_part(independence, node).should == '1st'
105
+ expect(renderer.render_date_part(independence, node)).to eq('1st')
106
106
  end
107
107
  end
108
108
 
@@ -110,34 +110,34 @@ module CiteProc
110
110
  before(:each) { node[:name] = 'month' }
111
111
 
112
112
  it "renders the month's full name by default" do
113
- renderer.render_date_part(january, node).should == 'January'
114
- renderer.render_date_part(december, node).should == 'December'
113
+ expect(renderer.render_date_part(january, node)).to eq('January')
114
+ expect(renderer.render_date_part(december, node)).to eq('December')
115
115
  end
116
116
 
117
117
  it "renders the month's full name as the long form" do
118
118
  node[:form] = 'long'
119
- renderer.render_date_part(january, node).should == 'January'
119
+ expect(renderer.render_date_part(january, node)).to eq('January')
120
120
  end
121
121
 
122
122
  it "renders the month's short name as the short form" do
123
123
  node[:form] = 'short'
124
- renderer.render_date_part(january, node).should == 'Jan.'
124
+ expect(renderer.render_date_part(january, node)).to eq('Jan.')
125
125
  end
126
126
 
127
127
  it 'renders the month as number as the numeric form' do
128
128
  node[:form] = 'numeric'
129
- renderer.render_date_part(january, node).should == '1'
129
+ expect(renderer.render_date_part(january, node)).to eq('1')
130
130
  end
131
131
 
132
132
  it 'renders the month as number with a leading zero when form is set to numeric-leading-zeros' do
133
133
  node[:form] = 'numeric-leading-zeros'
134
- renderer.render_date_part(january, node).should == '01'
135
- renderer.render_date_part(december, node).should == '12'
134
+ expect(renderer.render_date_part(january, node)).to eq('01')
135
+ expect(renderer.render_date_part(december, node)).to eq('12')
136
136
  end
137
137
 
138
138
  it 'renders the name of the season when a season is set' do
139
139
  january.season = 4
140
- renderer.render_date_part(january, node).should == 'Winter'
140
+ expect(renderer.render_date_part(january, node)).to eq('Winter')
141
141
  end
142
142
  end
143
143
 
@@ -145,17 +145,17 @@ module CiteProc
145
145
  before(:each) { node[:name] = 'year' }
146
146
 
147
147
  it 'renders the full year by default' do
148
- renderer.render_date_part(today, node).should == today.year.to_s
148
+ expect(renderer.render_date_part(today, node)).to eq(today.year.to_s)
149
149
  end
150
150
 
151
151
  it 'renders the full year when form is set to long' do
152
152
  node[:form] = 'long'
153
- renderer.render_date_part(january, node).should == '2012'
153
+ expect(renderer.render_date_part(january, node)).to eq('2012')
154
154
  end
155
155
 
156
156
  it 'renders the short year when form is set to short' do
157
157
  node[:form] = 'short'
158
- renderer.render_date_part(january, node).should == '12'
158
+ expect(renderer.render_date_part(january, node)).to eq('12')
159
159
  end
160
160
 
161
161
  it 'adds AD if applicable' do