hotdog 0.26.0 → 0.27.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 (16) hide show
  1. checksums.yaml +4 -4
  2. data/lib/hotdog/application.rb +61 -7
  3. data/lib/hotdog/commands/down.rb +3 -3
  4. data/lib/hotdog/commands/search.rb +9 -1
  5. data/lib/hotdog/commands/ssh.rb +14 -12
  6. data/lib/hotdog/commands.rb +54 -36
  7. data/lib/hotdog/expression/semantics.rb +162 -163
  8. data/lib/hotdog/version.rb +1 -1
  9. data/spec/core/commands_spec.rb +21 -0
  10. data/spec/optimizer/binary_expression_spec.rb +36 -34
  11. data/spec/optimizer/glob_expression_spec.rb +93 -91
  12. data/spec/optimizer/regexp_expression_spec.rb +43 -41
  13. data/spec/optimizer/string_expression_spec.rb +93 -91
  14. data/spec/optimizer/unary_expression_spec.rb +258 -257
  15. data/spec/spec_helper.rb +6 -0
  16. metadata +2 -2
data/spec/optimizer/unary_expression_spec.rb CHANGED
@@ -5,324 +5,325 @@ require "hotdog/commands/search"
5
5
  require "parslet"
6
6
 
7
7
  describe "unary expression" do
8
- it "NOT nothing should return everything" do
9
- expr = Hotdog::Expression::UnaryExpressionNode.new("NOT", Hotdog::Expression::NothingNode.new())
10
- expect(expr.optimize.dump).to eq({
11
- query: "SELECT id AS host_id FROM hosts;",
12
- values: [],
13
- })
14
- end
8
+ 3.times do |o|
9
+ it "NOT nothing should return everything (#{o})" do
10
+ expr = Hotdog::Expression::UnaryExpressionNode.new("NOT", Hotdog::Expression::NothingNode.new())
11
+ expect(optimize_n(o+1, expr).dump).to eq({
12
+ query: "SELECT id AS host_id FROM hosts;",
13
+ values: [],
14
+ })
15
+ end
15
16
 
16
- it "NOT everything should return nothing" do
17
- expr = Hotdog::Expression::UnaryExpressionNode.new("NOT", Hotdog::Expression::EverythingNode.new())
18
- expect(expr.optimize.dump).to eq({
19
- query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
20
- values: [],
21
- })
22
- end
17
+ it "NOT everything should return nothing (#{o})" do
18
+ expr = Hotdog::Expression::UnaryExpressionNode.new("NOT", Hotdog::Expression::EverythingNode.new())
19
+ expect(optimize_n(o+1, expr).dump).to eq({
20
+ query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
21
+ values: [],
22
+ })
23
+ end
23
24
 
24
- it "NOT NOT nothing should return nothing" do
25
- expr = Hotdog::Expression::UnaryExpressionNode.new(
26
- "NOT",
27
- Hotdog::Expression::UnaryExpressionNode.new(
25
+ it "NOT NOT nothing should return nothing (#{o})" do
26
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
28
27
  "NOT",
29
- Hotdog::Expression::NothingNode.new(),
30
- ),
31
- )
32
- expect(expr.optimize.dump).to eq({
33
- query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
34
- values: [],
35
- })
36
- end
28
+ Hotdog::Expression::UnaryExpressionNode.new(
29
+ "NOT",
30
+ Hotdog::Expression::NothingNode.new(),
31
+ ),
32
+ )
33
+ expect(optimize_n(o+1, expr).dump).to eq({
34
+ query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
35
+ values: [],
36
+ })
37
+ end
37
38
 
38
- it "NOT NOT everything should return everything" do
39
- expr = Hotdog::Expression::UnaryExpressionNode.new(
40
- "NOT",
41
- Hotdog::Expression::UnaryExpressionNode.new(
39
+ it "NOT NOT everything should return everything (#{o})" do
40
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
42
41
  "NOT",
43
- Hotdog::Expression::EverythingNode.new(),
44
- ),
45
- )
46
- expect(expr.optimize.dump).to eq({
47
- query: "SELECT id AS host_id FROM hosts;",
48
- values: [],
49
- })
50
- end
42
+ Hotdog::Expression::UnaryExpressionNode.new(
43
+ "NOT",
44
+ Hotdog::Expression::EverythingNode.new(),
45
+ ),
46
+ )
47
+ expect(optimize_n(o+1, expr).dump).to eq({
48
+ query: "SELECT id AS host_id FROM hosts;",
49
+ values: [],
50
+ })
51
+ end
51
52
 
52
- it "NOT NOT NOT nothing should return everything" do
53
- expr = Hotdog::Expression::UnaryExpressionNode.new(
54
- "NOT",
55
- Hotdog::Expression::UnaryExpressionNode.new(
53
+ it "NOT NOT NOT nothing should return everything (#{o})" do
54
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
56
55
  "NOT",
57
56
  Hotdog::Expression::UnaryExpressionNode.new(
58
57
  "NOT",
59
- Hotdog::Expression::NothingNode.new(),
58
+ Hotdog::Expression::UnaryExpressionNode.new(
59
+ "NOT",
60
+ Hotdog::Expression::NothingNode.new(),
61
+ ),
60
62
  ),
61
- ),
62
- )
63
- expect(expr.optimize.dump).to eq({
64
- query: "SELECT id AS host_id FROM hosts;",
65
- values: [],
66
- })
67
- end
63
+ )
64
+ expect(optimize_n(o+1, expr).dump).to eq({
65
+ query: "SELECT id AS host_id FROM hosts;",
66
+ values: [],
67
+ })
68
+ end
68
69
 
69
- it "NOT NOT NOT everything should return nothing" do
70
- expr = Hotdog::Expression::UnaryExpressionNode.new(
71
- "NOT",
72
- Hotdog::Expression::UnaryExpressionNode.new(
70
+ it "NOT NOT NOT everything should return nothing (#{o})" do
71
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
73
72
  "NOT",
74
73
  Hotdog::Expression::UnaryExpressionNode.new(
75
74
  "NOT",
76
- Hotdog::Expression::EverythingNode.new(),
75
+ Hotdog::Expression::UnaryExpressionNode.new(
76
+ "NOT",
77
+ Hotdog::Expression::EverythingNode.new(),
78
+ ),
77
79
  ),
78
- ),
79
- )
80
- expect(expr.optimize.dump).to eq({
81
- query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
82
- values: [],
83
- })
84
- end
85
-
86
- it "NOT host should return everything except the host" do
87
- expr = Hotdog::Expression::UnaryExpressionNode.new(
88
- "NOT",
89
- Hotdog::Expression::StringHostNode.new("foo", ":"),
90
- )
91
- expect(expr.optimize.dump).to eq({
92
- query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
93
- values: ["foo"],
94
- })
95
- end
80
+ )
81
+ expect(optimize_n(o+1, expr).dump).to eq({
82
+ query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
83
+ values: [],
84
+ })
85
+ end
96
86
 
97
- it "NOT NOT host should return the host" do
98
- expr = Hotdog::Expression::UnaryExpressionNode.new(
99
- "NOT",
100
- Hotdog::Expression::UnaryExpressionNode.new(
87
+ it "NOT host should return everything except the host (#{o})" do
88
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
101
89
  "NOT",
102
90
  Hotdog::Expression::StringHostNode.new("foo", ":"),
103
- ),
104
- )
105
- expect(expr.optimize.dump).to eq({
106
- tagname: "host",
107
- separator: ":",
108
- tagvalue: "foo",
109
- fallback: {
110
- query: [
111
- "SELECT hosts.id AS host_id FROM hosts",
112
- "WHERE LOWER(hosts.name) GLOB LOWER(?);",
113
- ].join(" "),
114
- values: ["*foo*"],
115
- },
116
- })
117
- end
91
+ )
92
+ expect(optimize_n(o+1, expr).dump).to eq({
93
+ query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
94
+ values: ["foo"],
95
+ })
96
+ end
118
97
 
119
- it "NOT NOT NOT host should return everything except the host" do
120
- expr = Hotdog::Expression::UnaryExpressionNode.new(
121
- "NOT",
122
- Hotdog::Expression::UnaryExpressionNode.new(
98
+ it "NOT NOT host should return the host (#{o})" do
99
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
123
100
  "NOT",
124
101
  Hotdog::Expression::UnaryExpressionNode.new(
125
102
  "NOT",
126
103
  Hotdog::Expression::StringHostNode.new("foo", ":"),
127
104
  ),
128
- ),
129
- )
130
- expect(expr.optimize.dump).to eq({
131
- query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
132
- values: ["foo"],
133
- })
134
- end
105
+ )
106
+ expect(optimize_n(o+1, expr).dump).to eq({
107
+ tagname: "host",
108
+ separator: ":",
109
+ tagvalue: "foo",
110
+ fallback: {
111
+ query: [
112
+ "SELECT hosts.id AS host_id FROM hosts",
113
+ "WHERE LOWER(hosts.name) GLOB LOWER(?);",
114
+ ].join(" "),
115
+ values: ["*foo*"],
116
+ },
117
+ })
118
+ end
135
119
 
136
- it "NOOP host should return the host" do
137
- expr = Hotdog::Expression::UnaryExpressionNode.new(
138
- "NOOP",
139
- Hotdog::Expression::StringHostNode.new("foo", ":"),
140
- )
141
- expect(expr.optimize.dump).to eq({
142
- tagname: "host",
143
- separator: ":",
144
- tagvalue: "foo",
145
- fallback: {
146
- query: [
147
- "SELECT hosts.id AS host_id FROM hosts",
148
- "WHERE LOWER(hosts.name) GLOB LOWER(?);",
149
- ].join(" "),
150
- values: ["*foo*"],
151
- },
152
- })
153
- end
120
+ it "NOT NOT NOT host should return everything except the host (#{o})" do
121
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
122
+ "NOT",
123
+ Hotdog::Expression::UnaryExpressionNode.new(
124
+ "NOT",
125
+ Hotdog::Expression::UnaryExpressionNode.new(
126
+ "NOT",
127
+ Hotdog::Expression::StringHostNode.new("foo", ":"),
128
+ ),
129
+ ),
130
+ )
131
+ expect(optimize_n(o+1, expr).dump).to eq({
132
+ query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
133
+ values: ["foo"],
134
+ })
135
+ end
154
136
 
155
- it "NOOP NOOP host should return the host" do
156
- expr = Hotdog::Expression::UnaryExpressionNode.new(
157
- "NOOP",
158
- Hotdog::Expression::UnaryExpressionNode.new(
137
+ it "NOOP host should return the host (#{o})" do
138
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
159
139
  "NOOP",
160
140
  Hotdog::Expression::StringHostNode.new("foo", ":"),
161
- ),
162
- )
163
- expect(expr.optimize.dump).to eq({
164
- tagname: "host",
165
- separator: ":",
166
- tagvalue: "foo",
167
- fallback: {
168
- query: [
169
- "SELECT hosts.id AS host_id FROM hosts",
170
- "WHERE LOWER(hosts.name) GLOB LOWER(?);",
171
- ].join(" "),
172
- values: ["*foo*"],
173
- },
174
- })
175
- end
141
+ )
142
+ expect(optimize_n(o+1, expr).dump).to eq({
143
+ tagname: "host",
144
+ separator: ":",
145
+ tagvalue: "foo",
146
+ fallback: {
147
+ query: [
148
+ "SELECT hosts.id AS host_id FROM hosts",
149
+ "WHERE LOWER(hosts.name) GLOB LOWER(?);",
150
+ ].join(" "),
151
+ values: ["*foo*"],
152
+ },
153
+ })
154
+ end
176
155
 
177
- it "NOOP NOOP NOOP host should return the host" do
178
- expr = Hotdog::Expression::UnaryExpressionNode.new(
179
- "NOOP",
180
- Hotdog::Expression::UnaryExpressionNode.new(
156
+ it "NOOP NOOP host should return the host (#{o})" do
157
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
181
158
  "NOOP",
182
159
  Hotdog::Expression::UnaryExpressionNode.new(
183
160
  "NOOP",
184
161
  Hotdog::Expression::StringHostNode.new("foo", ":"),
185
162
  ),
186
- ),
187
- )
188
- expect(expr.optimize.dump).to eq({
189
- tagname: "host",
190
- separator: ":",
191
- tagvalue: "foo",
192
- fallback: {
193
- query: [
194
- "SELECT hosts.id AS host_id FROM hosts",
195
- "WHERE LOWER(hosts.name) GLOB LOWER(?);",
196
- ].join(" "),
197
- values: ["*foo*"],
198
- },
199
- })
200
- end
163
+ )
164
+ expect(optimize_n(o+1, expr).dump).to eq({
165
+ tagname: "host",
166
+ separator: ":",
167
+ tagvalue: "foo",
168
+ fallback: {
169
+ query: [
170
+ "SELECT hosts.id AS host_id FROM hosts",
171
+ "WHERE LOWER(hosts.name) GLOB LOWER(?);",
172
+ ].join(" "),
173
+ values: ["*foo*"],
174
+ },
175
+ })
176
+ end
201
177
 
202
- it "NOT NOOP NOOP host should return everything except the host" do
203
- expr = Hotdog::Expression::UnaryExpressionNode.new(
204
- "NOT",
205
- Hotdog::Expression::UnaryExpressionNode.new(
178
+ it "NOOP NOOP NOOP host should return the host (#{o})" do
179
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
206
180
  "NOOP",
207
181
  Hotdog::Expression::UnaryExpressionNode.new(
208
182
  "NOOP",
209
- Hotdog::Expression::StringHostNode.new("foo", ":"),
183
+ Hotdog::Expression::UnaryExpressionNode.new(
184
+ "NOOP",
185
+ Hotdog::Expression::StringHostNode.new("foo", ":"),
186
+ ),
210
187
  ),
211
- ),
212
- )
213
- expect(expr.optimize.dump).to eq({
214
- query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
215
- values: ["foo"],
216
- })
217
- end
188
+ )
189
+ expect(optimize_n(o+1, expr).dump).to eq({
190
+ tagname: "host",
191
+ separator: ":",
192
+ tagvalue: "foo",
193
+ fallback: {
194
+ query: [
195
+ "SELECT hosts.id AS host_id FROM hosts",
196
+ "WHERE LOWER(hosts.name) GLOB LOWER(?);",
197
+ ].join(" "),
198
+ values: ["*foo*"],
199
+ },
200
+ })
201
+ end
218
202
 
219
- it "NOOP NOT NOOP host should return everything except the host" do
220
- expr = Hotdog::Expression::UnaryExpressionNode.new(
221
- "NOOP",
222
- Hotdog::Expression::UnaryExpressionNode.new(
203
+ it "NOT NOOP NOOP host should return everything except the host (#{o})" do
204
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
223
205
  "NOT",
224
206
  Hotdog::Expression::UnaryExpressionNode.new(
225
207
  "NOOP",
226
- Hotdog::Expression::StringHostNode.new("foo", ":"),
208
+ Hotdog::Expression::UnaryExpressionNode.new(
209
+ "NOOP",
210
+ Hotdog::Expression::StringHostNode.new("foo", ":"),
211
+ ),
227
212
  ),
228
- ),
229
- )
230
- expect(expr.optimize.dump).to eq({
231
- query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
232
- values: ["foo"],
233
- })
234
- end
213
+ )
214
+ expect(optimize_n(o+1, expr).dump).to eq({
215
+ query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
216
+ values: ["foo"],
217
+ })
218
+ end
235
219
 
236
- it "NOOP NOOP NOT host should return everything except the host" do
237
- expr = Hotdog::Expression::UnaryExpressionNode.new(
238
- "NOOP",
239
- Hotdog::Expression::UnaryExpressionNode.new(
220
+ it "NOOP NOT NOOP host should return everything except the host (#{o})" do
221
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
240
222
  "NOOP",
241
223
  Hotdog::Expression::UnaryExpressionNode.new(
242
224
  "NOT",
243
- Hotdog::Expression::StringHostNode.new("foo", ":"),
225
+ Hotdog::Expression::UnaryExpressionNode.new(
226
+ "NOOP",
227
+ Hotdog::Expression::StringHostNode.new("foo", ":"),
228
+ ),
244
229
  ),
245
- ),
246
- )
247
- expect(expr.optimize.dump).to eq({
248
- query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
249
- values: ["foo"],
250
- })
251
- end
230
+ )
231
+ expect(optimize_n(o+1, expr).dump).to eq({
232
+ query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
233
+ values: ["foo"],
234
+ })
235
+ end
252
236
 
253
- it "NOOP NOT NOT host should return everything except the host" do
254
- expr = Hotdog::Expression::UnaryExpressionNode.new(
255
- "NOT",
256
- Hotdog::Expression::UnaryExpressionNode.new(
257
- "NOT",
237
+ it "NOOP NOOP NOT host should return everything except the host (#{o})" do
238
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
239
+ "NOOP",
258
240
  Hotdog::Expression::UnaryExpressionNode.new(
259
241
  "NOOP",
260
- Hotdog::Expression::StringHostNode.new("foo", ":"),
242
+ Hotdog::Expression::UnaryExpressionNode.new(
243
+ "NOT",
244
+ Hotdog::Expression::StringHostNode.new("foo", ":"),
245
+ ),
261
246
  ),
262
- ),
263
- )
264
- expect(expr.optimize.dump).to eq({
265
- tagname: "host",
266
- separator: ":",
267
- tagvalue: "foo",
268
- fallback: {
269
- query: [
270
- "SELECT hosts.id AS host_id FROM hosts",
271
- "WHERE LOWER(hosts.name) GLOB LOWER(?);",
272
- ].join(" "),
273
- values: ["*foo*"],
274
- },
275
- })
276
- end
247
+ )
248
+ expect(optimize_n(o+1, expr).dump).to eq({
249
+ query: "SELECT id AS host_id FROM hosts EXCEPT SELECT hosts.id AS host_id FROM hosts WHERE hosts.name = ?;",
250
+ values: ["foo"],
251
+ })
252
+ end
277
253
 
278
- it "NOT NOOP NOT host should return everything except the host" do
279
- pending("optimization of 2+ depth unary expression is not yet supported")
280
- expr = Hotdog::Expression::UnaryExpressionNode.new(
281
- "NOT",
282
- Hotdog::Expression::UnaryExpressionNode.new(
283
- "NOOP",
254
+ it "NOOP NOT NOT host should return everything except the host (#{o})" do
255
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
256
+ "NOT",
284
257
  Hotdog::Expression::UnaryExpressionNode.new(
285
258
  "NOT",
286
- Hotdog::Expression::StringHostNode.new("foo", ":"),
259
+ Hotdog::Expression::UnaryExpressionNode.new(
260
+ "NOOP",
261
+ Hotdog::Expression::StringHostNode.new("foo", ":"),
262
+ ),
287
263
  ),
288
- ),
289
- )
290
- expect(expr.optimize.dump).to eq({
291
- tagname: "host",
292
- separator: ":",
293
- tagvalue: "foo",
294
- fallback: {
295
- query: [
296
- "SELECT hosts.id AS host_id FROM hosts",
297
- "WHERE LOWER(hosts.name) GLOB LOWER(?);",
298
- ].join(" "),
299
- values: ["*foo*"],
300
- },
301
- })
302
- end
264
+ )
265
+ expect(optimize_n(o+1, expr).dump).to eq({
266
+ tagname: "host",
267
+ separator: ":",
268
+ tagvalue: "foo",
269
+ fallback: {
270
+ query: [
271
+ "SELECT hosts.id AS host_id FROM hosts",
272
+ "WHERE LOWER(hosts.name) GLOB LOWER(?);",
273
+ ].join(" "),
274
+ values: ["*foo*"],
275
+ },
276
+ })
277
+ end
303
278
 
304
- it "NOT NOT NOOP host should return everything except the host" do
305
- expr = Hotdog::Expression::UnaryExpressionNode.new(
306
- "NOT",
307
- Hotdog::Expression::UnaryExpressionNode.new(
279
+ it "NOT NOOP NOT host should return everything except the host (#{o})" do
280
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
308
281
  "NOT",
309
282
  Hotdog::Expression::UnaryExpressionNode.new(
310
283
  "NOOP",
311
- Hotdog::Expression::StringHostNode.new("foo", ":"),
284
+ Hotdog::Expression::UnaryExpressionNode.new(
285
+ "NOT",
286
+ Hotdog::Expression::StringHostNode.new("foo", ":"),
287
+ ),
288
+ ),
289
+ )
290
+ expect(optimize_n(o+1, expr).dump).to eq({
291
+ tagname: "host",
292
+ separator: ":",
293
+ tagvalue: "foo",
294
+ fallback: {
295
+ query: [
296
+ "SELECT hosts.id AS host_id FROM hosts",
297
+ "WHERE LOWER(hosts.name) GLOB LOWER(?);",
298
+ ].join(" "),
299
+ values: ["*foo*"],
300
+ },
301
+ })
302
+ end
303
+
304
+ it "NOT NOT NOOP host should return everything except the host (#{o})" do
305
+ expr = Hotdog::Expression::UnaryExpressionNode.new(
306
+ "NOT",
307
+ Hotdog::Expression::UnaryExpressionNode.new(
308
+ "NOT",
309
+ Hotdog::Expression::UnaryExpressionNode.new(
310
+ "NOOP",
311
+ Hotdog::Expression::StringHostNode.new("foo", ":"),
312
+ ),
312
313
  ),
313
- ),
314
- )
315
- expect(expr.optimize.dump).to eq({
316
- tagname: "host",
317
- separator: ":",
318
- tagvalue: "foo",
319
- fallback: {
320
- query: [
321
- "SELECT hosts.id AS host_id FROM hosts",
322
- "WHERE LOWER(hosts.name) GLOB LOWER(?);",
323
- ].join(" "),
324
- values: ["*foo*"],
325
- },
326
- })
314
+ )
315
+ expect(optimize_n(o+1, expr).dump).to eq({
316
+ tagname: "host",
317
+ separator: ":",
318
+ tagvalue: "foo",
319
+ fallback: {
320
+ query: [
321
+ "SELECT hosts.id AS host_id FROM hosts",
322
+ "WHERE LOWER(hosts.name) GLOB LOWER(?);",
323
+ ].join(" "),
324
+ values: ["*foo*"],
325
+ },
326
+ })
327
+ end
327
328
  end
328
329
  end
data/spec/spec_helper.rb CHANGED
@@ -1 +1,7 @@
1
1
  require "rspec"
2
+
3
+ def optimize_n(n, x, options={})
4
+ n.times.reduce(x) { |x, _|
5
+ x.optimize(options)
6
+ }
7
+ end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: hotdog
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.26.0
4
+ version: 0.27.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Yamashita Yuu
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2017-08-25 00:00:00.000000000 Z
11
+ date: 2017-09-15 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: bundler