iv-phonic 0.1.0 → 0.1.1
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.
- data/Rakefile +1 -1
- data/ext/include/iv/ast.h +27 -39
- data/ext/include/iv/ast_factory.h +148 -51
- data/ext/include/iv/ast_fwd.h +8 -4
- data/ext/include/iv/ast_serializer.h +9 -0
- data/ext/include/iv/ast_visitor.h +3 -0
- data/ext/include/iv/lexer.h +37 -4
- data/ext/include/iv/parser.h +219 -109
- data/ext/iv/phonic/ast_fwd.h +6 -0
- data/ext/iv/phonic/creator.h +83 -24
- data/ext/iv/phonic/factory.h +258 -104
- data/test/test_iv_phonic.rb +8 -1
- metadata +2 -2
data/ext/iv/phonic/factory.h
CHANGED
@@ -17,35 +17,55 @@ class AstFactory : public core::Space<2> {
|
|
17
17
|
public:
|
18
18
|
AstFactory()
|
19
19
|
: core::Space<2>(),
|
20
|
-
undefined_instance_(new(this)Undefined())
|
21
|
-
|
22
|
-
|
23
|
-
|
24
|
-
|
25
|
-
true_instance_(new(this)TrueLiteral()),
|
26
|
-
false_instance_(new(this)FalseLiteral()) {
|
20
|
+
undefined_instance_(new(this)Undefined()) {
|
21
|
+
}
|
22
|
+
|
23
|
+
Scope* NewScope(FunctionLiteral::DeclType type) {
|
24
|
+
return new (this) Scope(this, type == FunctionLiteral::GLOBAL);
|
27
25
|
}
|
28
26
|
|
29
27
|
template<typename Range>
|
30
|
-
Identifier* NewIdentifier(const Range& range
|
28
|
+
Identifier* NewIdentifier(const Range& range,
|
29
|
+
std::size_t begin,
|
30
|
+
std::size_t end) {
|
31
31
|
Identifier* ident = new(this)Identifier(range, this);
|
32
|
+
ident->Location(begin, end);
|
32
33
|
return ident;
|
33
34
|
}
|
34
35
|
|
35
|
-
NumberLiteral* NewNumberLiteral(const double& val
|
36
|
-
|
36
|
+
NumberLiteral* NewNumberLiteral(const double& val,
|
37
|
+
std::size_t begin,
|
38
|
+
std::size_t end) {
|
39
|
+
NumberLiteral* num = new (this) NumberLiteral(val);
|
40
|
+
num->Location(begin, end);
|
41
|
+
return num;
|
37
42
|
}
|
38
43
|
|
39
|
-
|
40
|
-
|
44
|
+
NumberLiteral* NewReducedNumberLiteral(const double& val) {
|
45
|
+
UNREACHABLE();
|
46
|
+
return NULL;
|
41
47
|
}
|
42
48
|
|
43
|
-
|
44
|
-
|
49
|
+
StringLiteral* NewStringLiteral(const std::vector<uc16>& buffer,
|
50
|
+
std::size_t begin,
|
51
|
+
std::size_t end) {
|
52
|
+
StringLiteral* str = new (this) StringLiteral(buffer, this);
|
53
|
+
str->Location(begin, end);
|
54
|
+
return str;
|
55
|
+
}
|
56
|
+
|
57
|
+
Directivable* NewDirectivable(const std::vector<uc16>& buffer,
|
58
|
+
std::size_t begin,
|
59
|
+
std::size_t end) {
|
60
|
+
Directivable* directive = new (this) Directivable(buffer, this);
|
61
|
+
directive->Location(begin, end);
|
62
|
+
return directive;
|
45
63
|
}
|
46
64
|
|
47
65
|
RegExpLiteral* NewRegExpLiteral(const std::vector<uc16>& content,
|
48
|
-
const std::vector<uc16>& flags
|
66
|
+
const std::vector<uc16>& flags,
|
67
|
+
std::size_t begin,
|
68
|
+
std::size_t end) {
|
49
69
|
// OnigErrorInfo einfo;
|
50
70
|
// regex_t* reg;
|
51
71
|
// // TODO(Constellation) Little Endian?
|
@@ -60,19 +80,49 @@ class AstFactory : public core::Space<2> {
|
|
60
80
|
// return NULL;
|
61
81
|
// }
|
62
82
|
// onig_free(reg);
|
63
|
-
|
64
|
-
|
65
|
-
|
66
|
-
|
67
|
-
|
68
|
-
|
69
|
-
|
70
|
-
|
71
|
-
|
72
|
-
|
73
|
-
|
74
|
-
|
75
|
-
|
83
|
+
RegExpLiteral* reg = new (this) RegExpLiteral(content, flags, this);
|
84
|
+
reg->Location(begin, end);
|
85
|
+
return reg;
|
86
|
+
}
|
87
|
+
|
88
|
+
FunctionLiteral* NewFunctionLiteral(FunctionLiteral::DeclType type,
|
89
|
+
Identifier* name,
|
90
|
+
Identifiers* params,
|
91
|
+
Statements* body,
|
92
|
+
Scope* scope,
|
93
|
+
bool strict,
|
94
|
+
std::size_t begin_block_position,
|
95
|
+
std::size_t end_block_position,
|
96
|
+
std::size_t begin,
|
97
|
+
std::size_t end) {
|
98
|
+
FunctionLiteral* func = new (this)
|
99
|
+
FunctionLiteral(type,
|
100
|
+
name,
|
101
|
+
params,
|
102
|
+
body,
|
103
|
+
scope,
|
104
|
+
strict,
|
105
|
+
begin_block_position,
|
106
|
+
end_block_position);
|
107
|
+
func->Location(begin, end);
|
108
|
+
return func;
|
109
|
+
}
|
110
|
+
|
111
|
+
ArrayLiteral* NewArrayLiteral(Expressions* items,
|
112
|
+
std::size_t begin, std::size_t end) {
|
113
|
+
ArrayLiteral* ary = new (this) ArrayLiteral(items);
|
114
|
+
ary->Location(begin, end);
|
115
|
+
return ary;
|
116
|
+
}
|
117
|
+
|
118
|
+
|
119
|
+
ObjectLiteral*
|
120
|
+
NewObjectLiteral(ObjectLiteral::Properties* properties,
|
121
|
+
std::size_t begin,
|
122
|
+
std::size_t end) {
|
123
|
+
ObjectLiteral* obj = new (this) ObjectLiteral(properties);
|
124
|
+
obj->Location(begin, end);
|
125
|
+
return obj;
|
76
126
|
}
|
77
127
|
|
78
128
|
template<typename T>
|
@@ -86,189 +136,293 @@ class AstFactory : public core::Space<2> {
|
|
86
136
|
return new (New(sizeof(Vector))) Vector(typename Vector::allocator_type(this));
|
87
137
|
}
|
88
138
|
|
89
|
-
NullLiteral* NewNullLiteral(
|
90
|
-
|
139
|
+
NullLiteral* NewNullLiteral(std::size_t begin,
|
140
|
+
std::size_t end) {
|
141
|
+
NullLiteral* null = new (this) NullLiteral();
|
142
|
+
null->Location(begin, end);
|
143
|
+
return null;
|
91
144
|
}
|
92
145
|
|
93
|
-
|
94
|
-
|
146
|
+
ThisLiteral* NewThisLiteral(std::size_t begin, std::size_t end) {
|
147
|
+
ThisLiteral* th = new (this) ThisLiteral();
|
148
|
+
th->Location(begin, end);
|
149
|
+
return th;
|
95
150
|
}
|
96
151
|
|
97
|
-
|
98
|
-
return
|
152
|
+
Undefined* NewUndefined() {
|
153
|
+
return undefined_instance_;
|
99
154
|
}
|
100
155
|
|
101
|
-
|
102
|
-
|
156
|
+
TrueLiteral* NewTrueLiteral(std::size_t begin, std::size_t end) {
|
157
|
+
TrueLiteral* tr = new (this) TrueLiteral();
|
158
|
+
tr->Location(begin, end);
|
159
|
+
return tr;
|
103
160
|
}
|
104
161
|
|
105
|
-
|
106
|
-
|
162
|
+
FalseLiteral* NewFalseLiteral(std::size_t begin, std::size_t end) {
|
163
|
+
FalseLiteral* fal = new (this) FalseLiteral();
|
164
|
+
fal->Location(begin, end);
|
165
|
+
return fal;
|
107
166
|
}
|
108
167
|
|
109
|
-
|
110
|
-
|
168
|
+
EmptyStatement* NewEmptyStatement(std::size_t begin, std::size_t end) {
|
169
|
+
EmptyStatement* empty = new (this) EmptyStatement();
|
170
|
+
empty->Location(begin, end);
|
171
|
+
return empty;
|
111
172
|
}
|
112
173
|
|
113
|
-
|
114
|
-
|
174
|
+
DebuggerStatement* NewDebuggerStatement(std::size_t begin, std::size_t end) {
|
175
|
+
DebuggerStatement* debug = new (this) DebuggerStatement();
|
176
|
+
debug->Location(begin, end);
|
177
|
+
return debug;
|
115
178
|
}
|
116
179
|
|
117
180
|
FunctionStatement* NewFunctionStatement(FunctionLiteral* func) {
|
118
|
-
|
181
|
+
FunctionStatement* stmt = new (this) FunctionStatement(func);
|
182
|
+
stmt->Location(func->begin_position(), func->end_position());
|
183
|
+
return stmt;
|
119
184
|
}
|
120
185
|
|
121
186
|
FunctionDeclaration* NewFunctionDeclaration(FunctionLiteral* func) {
|
122
|
-
|
187
|
+
FunctionDeclaration* decl = new (this) FunctionDeclaration(func);
|
188
|
+
decl->Location(func->begin_position(), func->end_position());
|
189
|
+
return decl;
|
123
190
|
}
|
124
191
|
|
125
|
-
Block* NewBlock(Statements* body) {
|
126
|
-
|
192
|
+
Block* NewBlock(Statements* body, std::size_t begin, std::size_t end) {
|
193
|
+
Block* block = new (this) Block(body);
|
194
|
+
block->Location(begin, end);
|
195
|
+
return block;
|
127
196
|
}
|
128
197
|
|
129
198
|
VariableStatement* NewVariableStatement(core::Token::Type token,
|
130
|
-
Declarations* decls
|
131
|
-
|
199
|
+
Declarations* decls,
|
200
|
+
std::size_t begin,
|
201
|
+
std::size_t end) {
|
202
|
+
VariableStatement* var = new (this) VariableStatement(token, decls);
|
203
|
+
assert(!decls->empty());
|
204
|
+
var->Location(begin, end);
|
205
|
+
return var;
|
132
206
|
}
|
133
207
|
|
134
208
|
Declaration* NewDeclaration(Identifier* name, Expression* expr) {
|
135
|
-
|
209
|
+
assert(name && expr);
|
210
|
+
Declaration* decl = new (this) Declaration(name, expr);
|
211
|
+
const std::size_t end = (expr->AsUndefined()) ?
|
212
|
+
name->end_position() : expr->end_position();
|
213
|
+
decl->Location(name->begin_position(), end);
|
214
|
+
return decl;
|
136
215
|
}
|
137
216
|
|
138
217
|
IfStatement* NewIfStatement(Expression* cond,
|
139
218
|
Statement* then_statement,
|
140
|
-
Statement* else_statement
|
141
|
-
|
142
|
-
|
143
|
-
|
219
|
+
Statement* else_statement,
|
220
|
+
std::size_t begin) {
|
221
|
+
IfStatement* stmt = new (this) IfStatement(cond,
|
222
|
+
then_statement, else_statement);
|
223
|
+
assert(then_statement);
|
224
|
+
const std::size_t end = (else_statement) ?
|
225
|
+
else_statement->end_position() : then_statement->end_position();
|
226
|
+
stmt->Location(begin, end);
|
227
|
+
return stmt;
|
144
228
|
}
|
145
229
|
|
146
230
|
DoWhileStatement* NewDoWhileStatement(Statement* body,
|
147
|
-
Expression* cond
|
148
|
-
|
231
|
+
Expression* cond,
|
232
|
+
std::size_t begin,
|
233
|
+
std::size_t end) {
|
234
|
+
DoWhileStatement* stmt = new (this) DoWhileStatement(body, cond);
|
235
|
+
stmt->Location(begin, end);
|
236
|
+
return stmt;
|
149
237
|
}
|
150
238
|
|
151
239
|
WhileStatement* NewWhileStatement(Statement* body,
|
152
|
-
Expression* cond
|
153
|
-
|
240
|
+
Expression* cond,
|
241
|
+
std::size_t begin) {
|
242
|
+
assert(body && cond);
|
243
|
+
WhileStatement* stmt = new (this) WhileStatement(body, cond);
|
244
|
+
stmt->Location(begin, body->end_position());
|
245
|
+
return stmt;
|
154
246
|
}
|
155
247
|
|
156
248
|
ForInStatement* NewForInStatement(Statement* body,
|
157
249
|
Statement* each,
|
158
|
-
Expression* enumerable
|
159
|
-
|
160
|
-
|
161
|
-
|
162
|
-
|
163
|
-
return
|
250
|
+
Expression* enumerable,
|
251
|
+
std::size_t begin) {
|
252
|
+
assert(body);
|
253
|
+
ForInStatement* stmt = new (this) ForInStatement(body, each, enumerable);
|
254
|
+
stmt->Location(begin, body->end_position());
|
255
|
+
return stmt;
|
164
256
|
}
|
165
257
|
|
166
258
|
ForStatement* NewForStatement(Statement* body,
|
167
259
|
Statement* init,
|
168
260
|
Expression* cond,
|
169
|
-
Statement* next
|
170
|
-
|
261
|
+
Statement* next,
|
262
|
+
std::size_t begin) {
|
263
|
+
assert(body);
|
264
|
+
ForStatement* stmt = new (this) ForStatement(body, init, cond, next);
|
265
|
+
stmt->Location(begin, body->end_position());
|
266
|
+
return stmt;
|
171
267
|
}
|
172
268
|
|
269
|
+
ExpressionStatement* NewExpressionStatement(Expression* expr, std::size_t end) {
|
270
|
+
ExpressionStatement* stmt = new (this) ExpressionStatement(expr);
|
271
|
+
stmt->Location(expr->begin_position(), end);
|
272
|
+
return stmt;
|
273
|
+
}
|
173
274
|
|
174
275
|
ContinueStatement* NewContinueStatement(Identifier* label,
|
175
|
-
IterationStatement** target
|
176
|
-
|
276
|
+
IterationStatement** target,
|
277
|
+
std::size_t begin,
|
278
|
+
std::size_t end) {
|
279
|
+
ContinueStatement* stmt = new (this) ContinueStatement(label, target);
|
280
|
+
stmt->Location(begin, end);
|
281
|
+
return stmt;
|
177
282
|
}
|
178
283
|
|
179
284
|
BreakStatement* NewBreakStatement(Identifier* label,
|
180
|
-
BreakableStatement** target
|
181
|
-
|
285
|
+
BreakableStatement** target,
|
286
|
+
std::size_t begin,
|
287
|
+
std::size_t end) {
|
288
|
+
BreakStatement* stmt = new (this) BreakStatement(label, target);
|
289
|
+
stmt->Location(begin, end);
|
290
|
+
return stmt;
|
182
291
|
}
|
183
292
|
|
184
|
-
ReturnStatement* NewReturnStatement(Expression* expr
|
185
|
-
|
293
|
+
ReturnStatement* NewReturnStatement(Expression* expr,
|
294
|
+
std::size_t begin,
|
295
|
+
std::size_t end) {
|
296
|
+
assert(expr);
|
297
|
+
ReturnStatement* stmt = new (this) ReturnStatement(expr);
|
298
|
+
stmt->Location(begin, end);
|
299
|
+
return stmt;
|
186
300
|
}
|
187
301
|
|
188
|
-
WithStatement* NewWithStatement(Expression* expr,
|
189
|
-
|
302
|
+
WithStatement* NewWithStatement(Expression* expr,
|
303
|
+
Statement* body, std::size_t begin) {
|
304
|
+
assert(body);
|
305
|
+
WithStatement* stmt = new (this) WithStatement(expr, body);
|
306
|
+
stmt->Location(begin, body->end_position());
|
307
|
+
return stmt;
|
190
308
|
}
|
191
309
|
|
192
|
-
SwitchStatement* NewSwitchStatement(Expression* expr, CaseClauses* clauses
|
193
|
-
|
310
|
+
SwitchStatement* NewSwitchStatement(Expression* expr, CaseClauses* clauses,
|
311
|
+
std::size_t begin, std::size_t end) {
|
312
|
+
SwitchStatement* stmt = new (this) SwitchStatement(expr, clauses);
|
313
|
+
stmt->Location(begin, end);
|
314
|
+
return stmt;
|
194
315
|
}
|
195
316
|
|
196
317
|
CaseClause* NewCaseClause(bool is_default,
|
197
|
-
Expression* expr, Statements* body
|
198
|
-
|
318
|
+
Expression* expr, Statements* body,
|
319
|
+
std::size_t begin,
|
320
|
+
std::size_t end) {
|
321
|
+
CaseClause* clause = new (this) CaseClause(is_default, expr, body);
|
322
|
+
clause->Location(begin, end);
|
323
|
+
return clause;
|
199
324
|
}
|
200
325
|
|
201
326
|
|
202
|
-
ThrowStatement* NewThrowStatement(Expression* expr
|
203
|
-
|
327
|
+
ThrowStatement* NewThrowStatement(Expression* expr,
|
328
|
+
std::size_t begin,
|
329
|
+
std::size_t end) {
|
330
|
+
assert(expr);
|
331
|
+
ThrowStatement* stmt = new (this) ThrowStatement(expr);
|
332
|
+
stmt->Location(begin, end);
|
333
|
+
return stmt;
|
204
334
|
}
|
205
335
|
|
206
336
|
TryStatement* NewTryStatement(Block* try_block,
|
207
337
|
Identifier* catch_name,
|
208
338
|
Block* catch_block,
|
209
|
-
Block* finally_block
|
210
|
-
|
211
|
-
|
212
|
-
|
213
|
-
|
339
|
+
Block* finally_block,
|
340
|
+
std::size_t begin) {
|
341
|
+
TryStatement* stmt = new (this) TryStatement(try_block,
|
342
|
+
catch_name,
|
343
|
+
catch_block,
|
344
|
+
finally_block);
|
345
|
+
assert(catch_block || finally_block);
|
346
|
+
const std::size_t end = (finally_block) ?
|
347
|
+
finally_block->end_position() : catch_block->end_position();
|
348
|
+
stmt->Location(begin, end);
|
349
|
+
return stmt;
|
214
350
|
}
|
215
351
|
|
216
352
|
LabelledStatement* NewLabelledStatement(Expression* expr, Statement* stmt) {
|
217
|
-
|
353
|
+
LabelledStatement* label = new (this) LabelledStatement(expr, stmt);
|
354
|
+
label->Location(expr->begin_position(), stmt->end_position());
|
355
|
+
return label;
|
218
356
|
}
|
219
357
|
|
220
358
|
BinaryOperation* NewBinaryOperation(core::Token::Type op,
|
221
359
|
Expression* result,
|
222
360
|
Expression* right) {
|
223
|
-
|
361
|
+
BinaryOperation* expr = new (this) BinaryOperation(op, result, right);
|
362
|
+
expr->Location(result->begin_position(), right->end_position());
|
363
|
+
return expr;
|
224
364
|
}
|
225
365
|
|
226
366
|
Assignment* NewAssignment(core::Token::Type op,
|
227
367
|
Expression* left,
|
228
368
|
Expression* right) {
|
229
|
-
|
369
|
+
Assignment* expr = new (this) Assignment(op, left, right);
|
370
|
+
expr->Location(left->begin_position(), right->end_position());
|
371
|
+
return expr;
|
230
372
|
}
|
231
373
|
|
232
374
|
ConditionalExpression* NewConditionalExpression(Expression* cond,
|
233
375
|
Expression* left,
|
234
376
|
Expression* right) {
|
235
|
-
|
377
|
+
ConditionalExpression* expr = new (this) ConditionalExpression(cond, left, right);
|
378
|
+
expr->Location(cond->begin_position(), right->end_position());
|
379
|
+
return expr;
|
236
380
|
}
|
237
381
|
|
238
382
|
UnaryOperation* NewUnaryOperation(core::Token::Type op,
|
239
|
-
Expression* expr) {
|
240
|
-
|
383
|
+
Expression* expr, std::size_t begin) {
|
384
|
+
assert(expr);
|
385
|
+
UnaryOperation* unary = new (this) UnaryOperation(op, expr);
|
386
|
+
unary->Location(begin, expr->end_position());
|
387
|
+
return unary;
|
241
388
|
}
|
242
389
|
|
243
390
|
PostfixExpression* NewPostfixExpression(core::Token::Type op,
|
244
|
-
Expression* expr) {
|
245
|
-
|
391
|
+
Expression* expr, std::size_t end) {
|
392
|
+
assert(expr);
|
393
|
+
PostfixExpression* post = new (this) PostfixExpression(op, expr);
|
394
|
+
post->Location(expr->begin_position(), end);
|
395
|
+
return post;
|
246
396
|
}
|
247
397
|
|
248
|
-
FunctionCall* NewFunctionCall(Expression* expr,
|
249
|
-
|
398
|
+
FunctionCall* NewFunctionCall(Expression* expr,
|
399
|
+
Expressions* args, std::size_t end) {
|
400
|
+
FunctionCall* call = new (this) FunctionCall(expr, args);
|
401
|
+
call->Location(expr->begin_position(), end);
|
402
|
+
return call;
|
250
403
|
}
|
251
404
|
|
252
|
-
ConstructorCall* NewConstructorCall(Expression* target,
|
253
|
-
|
405
|
+
ConstructorCall* NewConstructorCall(Expression* target,
|
406
|
+
Expressions* args, std::size_t end) {
|
407
|
+
ConstructorCall* call = new (this) ConstructorCall(target, args);
|
408
|
+
call->Location(target->begin_position(), end);
|
409
|
+
return call;
|
254
410
|
}
|
255
411
|
|
256
412
|
IndexAccess* NewIndexAccess(Expression* expr, Expression* index) {
|
257
|
-
|
413
|
+
IndexAccess* access = new (this) IndexAccess(expr, index);
|
414
|
+
access->Location(expr->begin_position(), index->end_position());
|
415
|
+
return access;
|
258
416
|
}
|
259
417
|
|
260
418
|
IdentifierAccess* NewIdentifierAccess(Expression* expr, Identifier* ident) {
|
261
|
-
|
419
|
+
IdentifierAccess* access = new (this) IdentifierAccess(expr, ident);
|
420
|
+
access->Location(expr->begin_position(), ident->end_position());
|
421
|
+
return access;
|
262
422
|
}
|
263
423
|
|
264
424
|
private:
|
265
425
|
Undefined* undefined_instance_;
|
266
|
-
EmptyStatement* empty_statement_instance_;
|
267
|
-
DebuggerStatement* debugger_statement_instance_;
|
268
|
-
ThisLiteral* this_instance_;
|
269
|
-
NullLiteral* null_instance_;
|
270
|
-
TrueLiteral* true_instance_;
|
271
|
-
FalseLiteral* false_instance_;
|
272
426
|
};
|
273
427
|
|
274
428
|
|
data/test/test_iv_phonic.rb
CHANGED
@@ -23,10 +23,17 @@ class TestPhonic < Test::Unit::TestCase
|
|
23
23
|
assert(IV::Phonic::parse("T"))
|
24
24
|
assert(IV::Phonic::parse("var test = \"おはようございます\";"))
|
25
25
|
assert_raise(IV::Phonic::ParseError) {
|
26
|
-
IV::Phonic::parse("var test =
|
26
|
+
IV::Phonic::parse("var test =var;")
|
27
27
|
}
|
28
28
|
assert_nothing_raised {
|
29
29
|
IV::Phonic::parse("var test = /test/;")
|
30
30
|
}
|
31
|
+
pp IV::Phonic::parse("var i = 20;")
|
32
|
+
# assert_nothing_raised {
|
33
|
+
# IV::Phonic::parse(File.read('tmp/jquery.js'))
|
34
|
+
# }
|
35
|
+
# assert_nothing_raised {
|
36
|
+
# IV::Phonic::parse(File.read('tmp/dojo.js'))
|
37
|
+
# }
|
31
38
|
end
|
32
39
|
end
|
metadata
CHANGED
@@ -2,7 +2,7 @@
|
|
2
2
|
name: iv-phonic
|
3
3
|
version: !ruby/object:Gem::Version
|
4
4
|
prerelease:
|
5
|
-
version: 0.1.
|
5
|
+
version: 0.1.1
|
6
6
|
platform: ruby
|
7
7
|
authors:
|
8
8
|
- Constellation
|
@@ -10,7 +10,7 @@ autorequire:
|
|
10
10
|
bindir: bin
|
11
11
|
cert_chain: []
|
12
12
|
|
13
|
-
date: 2011-02-
|
13
|
+
date: 2011-02-09 00:00:00 +09:00
|
14
14
|
default_executable:
|
15
15
|
dependencies:
|
16
16
|
- !ruby/object:Gem::Dependency
|