sexp_processor 4.1.0 → 4.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.
Files changed (6) hide show
  1. data/History.txt +6 -0
  2. data/lib/pt_testcase.rb +83 -151
  3. data/lib/sexp_processor.rb +1 -1
  4. data.tar.gz.sig +2 -2
  5. metadata +4 -4
  6. metadata.gz.sig +0 -0
data/History.txt CHANGED
@@ -1,3 +1,9 @@
1
+ === 4.1.1 / 2012-11-02
2
+
3
+ * 1 minor enhancement:
4
+
5
+ * iter args revamp for ruby_parser 3 changes.
6
+
1
7
  === 4.1.0 / 2012-10-22
2
8
 
3
9
  * 1 minor enhancement:
data/lib/pt_testcase.rb CHANGED
@@ -272,15 +272,14 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
272
272
  "Ruby" => "a { |@a| 42 }",
273
273
  "ParseTree" => s(:iter,
274
274
  s(:call, nil, :a),
275
- s(:iasgn, :@a),
275
+ s(:args, :@a),
276
276
  s(:lit, 42)))
277
277
 
278
278
  add_18tests("iter_masgn_args_ivar",
279
279
  "Ruby" => "a { |a, @b| 42 }",
280
280
  "ParseTree" => s(:iter,
281
281
  s(:call, nil, :a),
282
- s(:masgn,
283
- s(:array, s(:lasgn, :a), s(:iasgn, :@b))),
282
+ s(:args, :a, :@b),
284
283
  s(:lit, 42)))
285
284
 
286
285
  add_18tests("not",
@@ -367,10 +366,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
367
366
  add_19edgecases("lambda { |x, y| (x + y) }",
368
367
  s(:iter,
369
368
  s(:call, nil, :lambda),
370
- s(:masgn,
371
- s(:array,
372
- s(:lasgn, :x),
373
- s(:lasgn, :y))),
369
+ s(:args, :x, :y),
374
370
  s(:call, s(:lvar, :x), :+, s(:lvar, :y))),
375
371
  "stabby_args_2" => "->(x, y) { (x + y) }",
376
372
  "stabby_args_2_doend" => "->(x, y) do (x + y) end",
@@ -380,7 +376,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
380
376
  add_19edgecases("lambda { |x| (x + 1) }",
381
377
  s(:iter,
382
378
  s(:call, nil, :lambda),
383
- s(:lasgn, :x),
379
+ s(:args, :x),
384
380
  s(:call, s(:lvar, :x), :+, s(:lit, 1))),
385
381
  "stabby_args_1" => "->(x) { (x + 1) }",
386
382
  "stabby_args_1_doend" => "->(x) do (x + 1) end",
@@ -456,40 +452,31 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
456
452
  add_19tests("call_splat_mid",
457
453
  "Ruby" => "def f(a = nil, *b, c) end",
458
454
  "ParseTree" => s(:defn, :f,
459
- s(:args, :a, :"*b", :c,
460
- s(:block, s(:lasgn, :a, s(:nil)))),
455
+ s(:args, s(:lasgn, :a, s(:nil)), :"*b", :c),
461
456
  s(:nil)))
462
457
 
463
458
  add_19tests("defn_args_mand_opt_mand",
464
459
  "Ruby" => "def f(mand1, opt = 42, mand2)\n # do nothing\nend",
465
460
  "ParseTree" => s(:defn, :f,
466
- s(:args, :mand1, :opt, :mand2,
467
- s(:block,
468
- s(:lasgn, :opt, s(:lit, 42)))),
461
+ s(:args, :mand1, s(:lasgn, :opt, s(:lit, 42)), :mand2),
469
462
  s(:nil)))
470
463
 
471
464
  add_19tests("defn_args_mand_opt_splat_mand",
472
465
  "Ruby" => "def f(mand1, opt = 42, *rest, mand2)\n # do nothing\nend",
473
466
  "ParseTree" => s(:defn, :f,
474
- s(:args, :mand1, :opt, :"*rest", :mand2,
475
- s(:block,
476
- s(:lasgn, :opt, s(:lit, 42)))),
467
+ s(:args, :mand1, s(:lasgn, :opt, s(:lit, 42)), :"*rest", :mand2),
477
468
  s(:nil)))
478
469
 
479
470
  add_19tests("defn_args_opt_mand",
480
471
  "Ruby" => "def f(opt = 42, mand)\n # do nothing\nend",
481
472
  "ParseTree" => s(:defn, :f,
482
- s(:args, :opt, :mand,
483
- s(:block,
484
- s(:lasgn, :opt, s(:lit, 42)))),
473
+ s(:args, s(:lasgn, :opt, s(:lit, 42)), :mand),
485
474
  s(:nil)))
486
475
 
487
476
  add_19tests("defn_args_opt_splat_mand",
488
477
  "Ruby" => "def f(opt = 42, *rest, mand)\n # do nothing\nend",
489
478
  "ParseTree" => s(:defn, :f,
490
- s(:args, :opt, :"*rest", :mand,
491
- s(:block,
492
- s(:lasgn, :opt, s(:lit, 42)))),
479
+ s(:args, s(:lasgn, :opt, s(:lit, 42)), :"*rest", :mand),
493
480
  s(:nil)))
494
481
 
495
482
  add_19tests("defn_args_splat_mand",
@@ -810,7 +797,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
810
797
  "Ruby" => "a(b) do\n if b then\n true\n else\n c = false\n d { |x| c = true }\n c\n end\nend",
811
798
  "ParseTree" => s(:iter,
812
799
  s(:call, nil, :a, s(:call, nil, :b)),
813
- nil,
800
+ s(:args),
814
801
  s(:if,
815
802
  s(:call, nil, :b),
816
803
  s(:true),
@@ -818,7 +805,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
818
805
  s(:lasgn, :c, s(:false)),
819
806
  s(:iter,
820
807
  s(:call, nil, :d),
821
- s(:lasgn, :x),
808
+ s(:args, :x),
822
809
  s(:lasgn, :c, s(:true))),
823
810
  s(:lvar, :c)))))
824
811
 
@@ -878,8 +865,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
878
865
  s(:block_pass,
879
866
  s(:iter,
880
867
  s(:call, s(:const, :Proc), :new),
881
- s(:masgn,
882
- s(:array, s(:splat, s(:lasgn, :args)))),
868
+ s(:args, :"*args"),
883
869
  s(:nil)))))
884
870
 
885
871
  add_tests("block_pass_splat",
@@ -967,13 +953,15 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
967
953
  add_tests("break",
968
954
  "Ruby" => "loop { break if true }",
969
955
  "ParseTree" => s(:iter,
970
- s(:call, nil, :loop), nil,
956
+ s(:call, nil, :loop),
957
+ s(:args),
971
958
  s(:if, s(:true), s(:break), nil)))
972
959
 
973
960
  add_tests("break_arg",
974
961
  "Ruby" => "loop { break 42 if true }",
975
962
  "ParseTree" => s(:iter,
976
- s(:call, nil, :loop), nil,
963
+ s(:call, nil, :loop),
964
+ s(:args),
977
965
  s(:if, s(:true), s(:break, s(:lit, 42)), nil)))
978
966
 
979
967
  add_tests("call",
@@ -1226,11 +1214,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1226
1214
  "Ruby" => "a.each { |x| b.each { |y| x = (x + 1) } if true }",
1227
1215
  "ParseTree" => s(:iter,
1228
1216
  s(:call, s(:call, nil, :a), :each),
1229
- s(:lasgn, :x),
1217
+ s(:args, :x),
1230
1218
  s(:if, s(:true),
1231
1219
  s(:iter,
1232
1220
  s(:call, s(:call, nil, :b), :each),
1233
- s(:lasgn, :y),
1221
+ s(:args, :y),
1234
1222
  s(:lasgn, :x,
1235
1223
  s(:call, s(:lvar, :x), :+, s(:lit, 1)))),
1236
1224
  nil)))
@@ -1239,11 +1227,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1239
1227
  "Ruby" => "a.each { |x| b.each { |y| c = (c + 1) } if true }",
1240
1228
  "ParseTree" => s(:iter,
1241
1229
  s(:call, s(:call, nil, :a), :each),
1242
- s(:lasgn, :x),
1230
+ s(:args, :x),
1243
1231
  s(:if, s(:true),
1244
1232
  s(:iter,
1245
1233
  s(:call, s(:call, nil, :b), :each),
1246
- s(:lasgn, :y),
1234
+ s(:args, :y),
1247
1235
  s(:lasgn, :c,
1248
1236
  s(:call, s(:lvar, :c), :+, s(:lit, 1)))),
1249
1237
  nil)))
@@ -1252,13 +1240,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1252
1240
  "Ruby" => "a.each do |x|\n if true then\n c = 0\n b.each { |y| c = (c + 1) }\n end\nend",
1253
1241
  "ParseTree" => s(:iter,
1254
1242
  s(:call, s(:call, nil, :a), :each),
1255
- s(:lasgn, :x),
1243
+ s(:args, :x),
1256
1244
  s(:if, s(:true),
1257
1245
  s(:block,
1258
1246
  s(:lasgn, :c, s(:lit, 0)),
1259
1247
  s(:iter,
1260
1248
  s(:call, s(:call, nil, :b), :each),
1261
- s(:lasgn, :y),
1249
+ s(:args, :y),
1262
1250
  s(:lasgn, :c,
1263
1251
  s(:call, s(:lvar, :c), :+,
1264
1252
  s(:lit, 1))))),
@@ -1268,8 +1256,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1268
1256
  "Ruby" => "data.each do |x, y|\n a = 1\n b = a\n b = a = x\nend",
1269
1257
  "ParseTree" => s(:iter,
1270
1258
  s(:call, s(:call, nil, :data), :each),
1271
- s(:masgn,
1272
- s(:array, s(:lasgn, :x), s(:lasgn, :y))),
1259
+ s(:args, :x, :y),
1273
1260
  s(:block,
1274
1261
  s(:lasgn, :a, s(:lit, 1)),
1275
1262
  s(:lasgn, :b, s(:lvar, :a)),
@@ -1279,13 +1266,13 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1279
1266
  "Ruby" => "a do\n v = nil\n assert_block(full_message) do\n begin\n yield\n rescue Exception => v\n break\n end\n end\nend",
1280
1267
  "ParseTree" => s(:iter,
1281
1268
  s(:call, nil, :a),
1282
- nil,
1269
+ s(:args),
1283
1270
  s(:block,
1284
1271
  s(:lasgn, :v, s(:nil)),
1285
1272
  s(:iter,
1286
1273
  s(:call, nil, :assert_block,
1287
1274
  s(:call, nil, :full_message)),
1288
- nil,
1275
+ s(:args),
1289
1276
  s(:rescue,
1290
1277
  s(:yield),
1291
1278
  s(:resbody,
@@ -1300,7 +1287,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1300
1287
  s(:lasgn, :t, s(:lit, 0)),
1301
1288
  s(:iter,
1302
1289
  s(:call, s(:call, nil, :ns), :each),
1303
- s(:lasgn, :n),
1290
+ s(:args, :n),
1304
1291
  s(:lasgn, :t,
1305
1292
  s(:call, s(:lvar, :t), :+, s(:lvar, :n))))),
1306
1293
  "Ruby2Ruby" => "t = 0\nns.each { |n| t = (t + n) }\n")
@@ -1327,40 +1314,31 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1327
1314
  add_tests("defn_args_mand_opt",
1328
1315
  "Ruby" => "def f(mand, opt = 42)\n # do nothing\nend",
1329
1316
  "ParseTree" => s(:defn, :f,
1330
- s(:args, :mand, :opt,
1331
- s(:block,
1332
- s(:lasgn, :opt, s(:lit, 42)))),
1317
+ s(:args, :mand, s(:lasgn, :opt, s(:lit, 42))),
1333
1318
  s(:nil)))
1334
1319
 
1335
1320
  add_tests("defn_args_mand_opt_block",
1336
1321
  "Ruby" => "def f(mand, opt = 42, &block)\n # do nothing\nend",
1337
1322
  "ParseTree" => s(:defn, :f,
1338
- s(:args, :mand, :opt, :"&block",
1339
- s(:block,
1340
- s(:lasgn, :opt, s(:lit, 42)))),
1323
+ s(:args, :mand, s(:lasgn, :opt, s(:lit, 42)), :"&block"),
1341
1324
  s(:nil)))
1342
1325
 
1343
1326
  add_tests("defn_args_mand_opt_splat",
1344
1327
  "Ruby" => "def f(mand, opt = 42, *rest)\n # do nothing\nend",
1345
1328
  "ParseTree" => s(:defn, :f,
1346
- s(:args, :mand, :opt, :"*rest",
1347
- s(:block,
1348
- s(:lasgn, :opt, s(:lit, 42)))),
1329
+ s(:args, :mand, s(:lasgn, :opt, s(:lit, 42)), :"*rest"),
1349
1330
  s(:nil)))
1350
1331
 
1351
1332
  add_tests("defn_args_mand_opt_splat_block",
1352
1333
  "Ruby" => "def f(mand, opt = 42, *rest, &block)\n # do nothing\nend",
1353
1334
  "ParseTree" => s(:defn, :f,
1354
- s(:args, :mand, :opt, :"*rest", :"&block",
1355
- s(:block,
1356
- s(:lasgn, :opt, s(:lit, 42)))),
1335
+ s(:args, :mand, s(:lasgn, :opt, s(:lit, 42)), :"*rest", :"&block"),
1357
1336
  s(:nil)))
1358
1337
 
1359
1338
  add_tests("defn_args_mand_opt_splat_no_name",
1360
1339
  "Ruby" => "def x(a, b = 42, *)\n # do nothing\nend",
1361
1340
  "ParseTree" => s(:defn, :x,
1362
- s(:args, :a, :b, :"*",
1363
- s(:block, s(:lasgn, :b, s(:lit, 42)))),
1341
+ s(:args, :a, s(:lasgn, :b, s(:lit, 42)), :"*"),
1364
1342
  s(:nil)))
1365
1343
 
1366
1344
  add_tests("defn_args_mand_splat",
@@ -1389,40 +1367,33 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1389
1367
  add_tests("defn_args_opt",
1390
1368
  "Ruby" => "def f(opt = 42)\n # do nothing\nend",
1391
1369
  "ParseTree" => s(:defn, :f,
1392
- s(:args, :opt,
1393
- s(:block,
1394
- s(:lasgn, :opt, s(:lit, 42)))),
1370
+ s(:args, s(:lasgn, :opt, s(:lit, 42))),
1395
1371
  s(:nil)))
1396
1372
 
1397
1373
  add_tests("defn_args_opt_block",
1398
1374
  "Ruby" => "def f(opt = 42, &block)\n # do nothing\nend",
1399
1375
  "ParseTree" => s(:defn, :f,
1400
- s(:args, :opt, :"&block",
1401
- s(:block,
1402
- s(:lasgn, :opt, s(:lit, 42)))),
1403
- s(:nil)))
1376
+ s(:args, s(:lasgn, :opt, s(:lit, 42)), :"&block"),
1377
+ s(:nil)))
1404
1378
 
1405
1379
  add_tests("defn_args_opt_splat",
1406
1380
  "Ruby" => "def f(opt = 42, *rest)\n # do nothing\nend",
1407
1381
  "ParseTree" => s(:defn, :f,
1408
- s(:args, :opt, :"*rest",
1409
- s(:block,
1410
- s(:lasgn, :opt, s(:lit, 42)))),
1382
+ s(:args, s(:lasgn, :opt, s(:lit, 42)), :"*rest"),
1411
1383
  s(:nil)))
1412
1384
 
1413
1385
  add_tests("defn_args_opt_splat_block",
1414
1386
  "Ruby" => "def f(opt = 42, *rest, &block)\n # do nothing\nend",
1415
1387
  "ParseTree" => s(:defn, :f,
1416
- s(:args, :opt, :"*rest", :"&block",
1417
- s(:block,
1418
- s(:lasgn, :opt, s(:lit, 42)))),
1388
+ s(:args,
1389
+ s(:lasgn, :opt, s(:lit, 42)),
1390
+ :"*rest", :"&block"),
1419
1391
  s(:nil)))
1420
1392
 
1421
1393
  add_tests("defn_args_opt_splat_no_name",
1422
1394
  "Ruby" => "def x(b = 42, *)\n # do nothing\nend",
1423
1395
  "ParseTree" => s(:defn, :x,
1424
- s(:args, :b, :"*",
1425
- s(:block, s(:lasgn, :b, s(:lit, 42)))),
1396
+ s(:args, s(:lasgn, :b, s(:lit, 42)), :"*"),
1426
1397
  s(:nil)))
1427
1398
 
1428
1399
  add_tests("defn_args_splat",
@@ -1733,7 +1704,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1733
1704
  "Ruby" => "a(:b) { :c }",
1734
1705
  "ParseTree" => s(:iter,
1735
1706
  s(:call, nil, :a, s(:lit, :b)),
1736
- nil,
1707
+ s(:args),
1737
1708
  s(:lit, :c)))
1738
1709
 
1739
1710
  add_tests("fcall_index_space",
@@ -1896,7 +1867,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1896
1867
  "Ruby" => "a (1) {|c|d}",
1897
1868
  "ParseTree" => s(:iter,
1898
1869
  s(:call, nil, :a, s(:lit, 1)),
1899
- s(:lasgn, :c),
1870
+ s(:args, :c),
1900
1871
  s(:call, nil, :d)),
1901
1872
  "Ruby2Ruby" => "a(1) { |c| d }")
1902
1873
 
@@ -1904,7 +1875,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1904
1875
  "Ruby" => "as.each { |a|\n b += a.b(false) }",
1905
1876
  "ParseTree" => s(:iter,
1906
1877
  s(:call, s(:call, nil, :as), :each),
1907
- s(:lasgn, :a),
1878
+ s(:args, :a),
1908
1879
  s(:lasgn, :b,
1909
1880
  s(:call,
1910
1881
  s(:lvar, :b),
@@ -1916,7 +1887,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1916
1887
  "Ruby" => "3.downto(1) { |n| puts(n.to_s) }",
1917
1888
  "ParseTree" => s(:iter,
1918
1889
  s(:call, s(:lit, 3), :downto, s(:lit, 1)),
1919
- s(:lasgn, :n),
1890
+ s(:args, :n),
1920
1891
  s(:call, nil, :puts,
1921
1892
  s(:call, s(:lvar, :n), :to_s))))
1922
1893
 
@@ -1928,7 +1899,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1928
1899
  s(:lit, 1), s(:lit, 2), s(:lit, 3))),
1929
1900
  s(:iter,
1930
1901
  s(:call, s(:lvar, :array), :each),
1931
- s(:lasgn, :x),
1902
+ s(:args, :x),
1932
1903
  s(:call, nil, :puts,
1933
1904
  s(:call, s(:lvar, :x), :to_s)))))
1934
1905
 
@@ -1943,13 +1914,11 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1943
1914
  s(:lit, 4), s(:lit, 5),
1944
1915
  s(:lit, 6), s(:lit, 7))),
1945
1916
  s(:iter,
1946
- s(:call,
1947
- s(:lvar, :array1), :each),
1948
- s(:lasgn, :x),
1917
+ s(:call, s(:lvar, :array1), :each),
1918
+ s(:args, :x),
1949
1919
  s(:iter,
1950
- s(:call,
1951
- s(:lvar, :array2), :each),
1952
- s(:lasgn, :y),
1920
+ s(:call, s(:lvar, :array2), :each),
1921
+ s(:args, :y),
1953
1922
  s(:block,
1954
1923
  s(:call, nil, :puts,
1955
1924
  s(:call, s(:lvar, :x), :to_s)),
@@ -1958,60 +1927,51 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
1958
1927
 
1959
1928
  add_tests("iter_loop_empty",
1960
1929
  "Ruby" => "loop { }",
1961
- "ParseTree" => s(:iter, s(:call, nil, :loop), nil))
1930
+ "ParseTree" => s(:iter, s(:call, nil, :loop), s(:args)))
1962
1931
 
1963
1932
  add_tests("iter_masgn_2",
1964
1933
  "Ruby" => "a { |b, c| p(c) }",
1965
1934
  "ParseTree" => s(:iter,
1966
1935
  s(:call, nil, :a),
1967
- s(:masgn,
1968
- s(:array, s(:lasgn, :b), s(:lasgn, :c))),
1936
+ s(:args, :b, :c),
1969
1937
  s(:call, nil, :p, s(:lvar, :c))))
1970
1938
 
1971
1939
  add_tests("iter_masgn_args_splat",
1972
1940
  "Ruby" => "a { |b, c, *d| p(c) }",
1973
1941
  "ParseTree" => s(:iter,
1974
1942
  s(:call, nil, :a),
1975
- s(:masgn,
1976
- s(:array,
1977
- s(:lasgn, :b),
1978
- s(:lasgn, :c),
1979
- s(:splat, s(:lasgn, :d)))),
1943
+ s(:args, :b, :c, :"*d"),
1980
1944
  s(:call, nil, :p, s(:lvar, :c))))
1981
1945
 
1982
1946
  add_tests("iter_masgn_args_splat_no_name",
1983
1947
  "Ruby" => "a { |b, c, *| p(c) }",
1984
1948
  "ParseTree" => s(:iter,
1985
1949
  s(:call, nil, :a),
1986
- s(:masgn,
1987
- s(:array,
1988
- s(:lasgn, :b),
1989
- s(:lasgn, :c),
1990
- s(:splat))),
1950
+ s(:args, :b, :c, :*),
1991
1951
  s(:call, nil, :p, s(:lvar, :c))))
1992
1952
 
1993
1953
  add_tests("iter_masgn_splat",
1994
1954
  "Ruby" => "a { |*c| p(c) }",
1995
1955
  "ParseTree" => s(:iter,
1996
1956
  s(:call, nil, :a),
1997
- s(:masgn, s(:array, s(:splat, s(:lasgn, :c)))),
1957
+ s(:args, :"*c"),
1998
1958
  s(:call, nil, :p, s(:lvar, :c))))
1999
1959
 
2000
1960
  add_tests("iter_masgn_splat_no_name",
2001
1961
  "Ruby" => "a { |*| p(c) }",
2002
1962
  "ParseTree" => s(:iter,
2003
1963
  s(:call, nil, :a),
2004
- s(:masgn, s(:array, s(:splat))),
1964
+ s(:args, :*),
2005
1965
  s(:call, nil, :p, s(:call, nil, :c))))
2006
1966
 
2007
1967
  add_tests("iter_shadowed_var",
2008
1968
  "Ruby" => "a do |x|\n b do |x|\n puts x\n end\nend",
2009
1969
  "ParseTree" => s(:iter,
2010
1970
  s(:call, nil, :a),
2011
- s(:lasgn, :x),
1971
+ s(:args, :x),
2012
1972
  s(:iter,
2013
1973
  s(:call, nil, :b),
2014
- s(:lasgn, :x),
1974
+ s(:args, :x),
2015
1975
  s(:call, nil, :puts, s(:lvar, :x)))),
2016
1976
  "Ruby2Ruby" => "a { |x| b { |x| puts(x) } }")
2017
1977
 
@@ -2019,7 +1979,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2019
1979
  "Ruby" => "1.upto(3) { |n| puts(n.to_s) }",
2020
1980
  "ParseTree" => s(:iter,
2021
1981
  s(:call, s(:lit, 1), :upto, s(:lit, 3)),
2022
- s(:lasgn, :n),
1982
+ s(:args, :n),
2023
1983
  s(:call, nil, :puts,
2024
1984
  s(:call, s(:lvar, :n), :to_s))))
2025
1985
 
@@ -2047,58 +2007,49 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2047
2007
  "Ruby" => "lambda { |*| nil }",
2048
2008
  "ParseTree" => s(:iter,
2049
2009
  s(:call, nil, :lambda),
2050
- s(:masgn, s(:array, s(:splat))),
2010
+ s(:args, :*),
2051
2011
  s(:nil)))
2052
2012
 
2053
2013
  add_tests("lambda_args_anon_star_block",
2054
2014
  "Ruby" => "lambda { |*, &block| block }",
2055
2015
  "ParseTree" => s(:iter,
2056
2016
  s(:call, nil, :lambda),
2057
- s(:masgn, s(:array,
2058
- s(:splat),
2059
- s(:lasgn, :"&block"))),
2017
+ s(:args, :*, :"&block"),
2060
2018
  s(:lvar, :block)))
2061
2019
 
2062
2020
  add_tests("lambda_args_block",
2063
2021
  "Ruby" => "lambda { |&block| block }",
2064
2022
  "ParseTree" => s(:iter,
2065
2023
  s(:call, nil, :lambda),
2066
- s(:lasgn, :"&block"),
2024
+ s(:args, :"&block"),
2067
2025
  s(:lvar, :block)))
2068
2026
 
2069
2027
  add_tests("lambda_args_norm_anon_star",
2070
2028
  "Ruby" => "lambda { |a, *| a }",
2071
2029
  "ParseTree" => s(:iter,
2072
2030
  s(:call, nil, :lambda),
2073
- s(:masgn, s(:array,
2074
- s(:lasgn, :a),
2075
- s(:splat))),
2031
+ s(:args, :a, :*),
2076
2032
  s(:lvar, :a)))
2077
2033
 
2078
2034
  add_tests("lambda_args_norm_anon_star_block",
2079
2035
  "Ruby" => "lambda { |a, *, &block| block }",
2080
2036
  "ParseTree" => s(:iter,
2081
2037
  s(:call, nil, :lambda),
2082
- s(:masgn, s(:array,
2083
- s(:lasgn, :a),
2084
- s(:splat),
2085
- s(:lasgn, :"&block"))),
2038
+ s(:args, :a, :*, :"&block"),
2086
2039
  s(:lvar, :block)))
2087
2040
 
2088
2041
  add_tests("lambda_args_norm_block",
2089
2042
  "Ruby" => "lambda { |a, &block| block }",
2090
2043
  "ParseTree" => s(:iter,
2091
2044
  s(:call, nil, :lambda),
2092
- s(:masgn, s(:array,
2093
- s(:lasgn, :a),
2094
- s(:lasgn, :"&block"))),
2045
+ s(:args, :a, :"&block"),
2095
2046
  s(:lvar, :block)))
2096
2047
 
2097
2048
  add_tests("lambda_args_norm_comma",
2098
2049
  "Ruby" => "lambda { |a,| a }",
2099
2050
  "ParseTree" => s(:iter,
2100
2051
  s(:call, nil, :lambda),
2101
- s(:lasgn, :a),
2052
+ s(:args, :a),
2102
2053
  s(:lvar, :a)),
2103
2054
  "Ruby2Ruby" => "lambda { |a| a }")
2104
2055
 
@@ -2106,8 +2057,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2106
2057
  "Ruby" => "lambda { |a,b,| a }",
2107
2058
  "ParseTree" => s(:iter,
2108
2059
  s(:call, nil, :lambda),
2109
- s(:masgn,
2110
- s(:array, s(:lasgn, :a), s(:lasgn, :b))),
2060
+ s(:args, :a, :b),
2111
2061
  s(:lvar, :a)),
2112
2062
  "Ruby2Ruby" => "lambda { |a, b| a }")
2113
2063
 
@@ -2115,36 +2065,28 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2115
2065
  "Ruby" => "lambda { |a, *star| star }",
2116
2066
  "ParseTree" => s(:iter,
2117
2067
  s(:call, nil, :lambda),
2118
- s(:masgn, s(:array,
2119
- s(:lasgn, :a),
2120
- s(:splat, s(:lasgn, :star)))),
2068
+ s(:args, :a, :"*star"),
2121
2069
  s(:lvar, :star)))
2122
2070
 
2123
2071
  add_tests("lambda_args_norm_star_block",
2124
2072
  "Ruby" => "lambda { |a, *star, &block| block }",
2125
2073
  "ParseTree" => s(:iter,
2126
2074
  s(:call, nil, :lambda),
2127
- s(:masgn, s(:array,
2128
- s(:lasgn, :a),
2129
- s(:splat, s(:lasgn, :star)),
2130
- s(:lasgn, :"&block"))),
2075
+ s(:args, :a, :"*star", :"&block"),
2131
2076
  s(:lvar, :block)))
2132
2077
 
2133
2078
  add_tests("lambda_args_star",
2134
2079
  "Ruby" => "lambda { |*star| star }",
2135
2080
  "ParseTree" => s(:iter,
2136
2081
  s(:call, nil, :lambda),
2137
- s(:masgn, s(:array,
2138
- s(:splat, s(:lasgn, :star)))),
2082
+ s(:args, :"*star"),
2139
2083
  s(:lvar, :star)))
2140
2084
 
2141
2085
  add_tests("lambda_args_star_block",
2142
2086
  "Ruby" => "lambda { |*star, &block| block }",
2143
2087
  "ParseTree" => s(:iter,
2144
2088
  s(:call, nil, :lambda),
2145
- s(:masgn, s(:array,
2146
- s(:splat, s(:lasgn, :star)),
2147
- s(:lasgn, :"&block"))),
2089
+ s(:args, :"*star", :"&block"),
2148
2090
  s(:lvar, :block)))
2149
2091
 
2150
2092
  add_tests("lasgn_array",
@@ -2223,7 +2165,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2223
2165
  s(:defn, :a, s(:args),
2224
2166
  s(:iter,
2225
2167
  s(:call, nil, :c),
2226
- nil,
2168
+ s(:args),
2227
2169
  s(:rescue,
2228
2170
  s(:call, nil, :do_stuff),
2229
2171
  s(:resbody,
@@ -2436,14 +2378,14 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2436
2378
  "Ruby" => "loop { next if false }",
2437
2379
  "ParseTree" => s(:iter,
2438
2380
  s(:call, nil, :loop),
2439
- nil,
2381
+ s(:args),
2440
2382
  s(:if, s(:false), s(:next), nil)))
2441
2383
 
2442
2384
  add_tests("next_arg",
2443
2385
  "Ruby" => "loop { next 42 if false }",
2444
2386
  "ParseTree" => s(:iter,
2445
2387
  s(:call, nil, :loop),
2446
- nil,
2388
+ s(:args),
2447
2389
  s(:if, s(:false), s(:next, s(:lit, 42)), nil)))
2448
2390
 
2449
2391
  add_tests("nth_ref",
@@ -2585,16 +2527,15 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2585
2527
  add_tests("parse_floats_as_args",
2586
2528
  "Ruby" => "def x(a=0.0,b=0.0)\n a+b\nend",
2587
2529
  "ParseTree" => s(:defn, :x,
2588
- s(:args, :a, :b,
2589
- s(:block,
2590
- s(:lasgn, :a, s(:lit, 0.0)),
2591
- s(:lasgn, :b, s(:lit, 0.0)))),
2530
+ s(:args,
2531
+ s(:lasgn, :a, s(:lit, 0.0)),
2532
+ s(:lasgn, :b, s(:lit, 0.0))),
2592
2533
  s(:call, s(:lvar, :a), :+, s(:lvar, :b))),
2593
2534
  "Ruby2Ruby" => "def x(a = 0.0, b = 0.0)\n (a + b)\nend")
2594
2535
 
2595
2536
  add_tests("postexe",
2596
2537
  "Ruby" => "END { 1 }",
2597
- "ParseTree" => s(:iter, s(:postexe), nil, s(:lit, 1)))
2538
+ "ParseTree" => s(:iter, s(:postexe), s(:args), s(:lit, 1)))
2598
2539
 
2599
2540
  add_tests("proc_args_0",
2600
2541
  "Ruby" => "proc { || (x + 1) }",
@@ -2607,31 +2548,28 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2607
2548
  "Ruby" => "proc { |x| (x + 1) }",
2608
2549
  "ParseTree" => s(:iter,
2609
2550
  s(:call, nil, :proc),
2610
- s(:lasgn, :x),
2551
+ s(:args, :x),
2611
2552
  s(:call, s(:lvar, :x), :+, s(:lit, 1))))
2612
2553
 
2613
2554
  add_tests("proc_args_2",
2614
2555
  "Ruby" => "proc { |x, y| (x + y) }",
2615
2556
  "ParseTree" => s(:iter,
2616
2557
  s(:call, nil, :proc),
2617
- s(:masgn,
2618
- s(:array,
2619
- s(:lasgn, :x),
2620
- s(:lasgn, :y))),
2558
+ s(:args, :x, :y),
2621
2559
  s(:call, s(:lvar, :x), :+, s(:lvar, :y))))
2622
2560
 
2623
2561
  add_tests("proc_args_no",
2624
2562
  "Ruby" => "proc { (x + 1) }",
2625
2563
  "ParseTree" => s(:iter,
2626
2564
  s(:call, nil, :proc),
2627
- nil,
2565
+ s(:args),
2628
2566
  s(:call, s(:call, nil, :x), :+, s(:lit, 1))))
2629
2567
 
2630
2568
  add_tests("redo",
2631
2569
  "Ruby" => "loop { redo if false }",
2632
2570
  "ParseTree" => s(:iter,
2633
2571
  s(:call, nil, :loop),
2634
- nil,
2572
+ s(:args),
2635
2573
  s(:if, s(:false), s(:redo), nil)))
2636
2574
 
2637
2575
  add_tests("rescue", # TODO: need a resbody w/ multiple classes and a splat
@@ -2889,12 +2827,8 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2889
2827
  add_tests("structure_extra_block_for_dvar_scoping",
2890
2828
  "Ruby" => "a.b do |c, d|\n unless e.f(c) then\n g = false\n d.h { |x, i| g = true }\n end\nend",
2891
2829
  "ParseTree" => s(:iter,
2892
- s(:call,
2893
- s(:call, nil, :a),
2894
- :b),
2895
- s(:masgn, s(:array,
2896
- s(:lasgn, :c),
2897
- s(:lasgn, :d))),
2830
+ s(:call, s(:call, nil, :a), :b),
2831
+ s(:args, :c, :d),
2898
2832
  s(:if,
2899
2833
  s(:call, s(:call, nil, :e), :f, s(:lvar, :c)),
2900
2834
  nil,
@@ -2902,9 +2836,7 @@ class ParseTreeTestCase < MiniTest::Unit::TestCase
2902
2836
  s(:lasgn, :g, s(:false)),
2903
2837
  s(:iter,
2904
2838
  s(:call, s(:lvar, :d), :h),
2905
- s(:masgn, s(:array,
2906
- s(:lasgn, :x),
2907
- s(:lasgn, :i))),
2839
+ s(:args, :x, :i),
2908
2840
  s(:lasgn, :g, s(:true)))))))
2909
2841
 
2910
2842
  add_tests("structure_remove_begin_1",
data/lib/sexp_processor.rb CHANGED
@@ -34,7 +34,7 @@ require 'sexp'
34
34
 
35
35
  class SexpProcessor
36
36
 
37
- VERSION = '4.1.0'
37
+ VERSION = '4.1.1'
38
38
 
39
39
  ##
40
40
  # Automatically shifts off the Sexp type before handing the
data.tar.gz.sig CHANGED
@@ -1,2 +1,2 @@
1
- �ʠ�����6���|݊��`��WF�6�S�������b�|O��u�B�6o�L�u��.3�B��0Y�Ldw�(��QïCZ$��� :��z �`e@�]سY:������5G#�"ԕ!H.����C:kw��K\j��!F7`ҵ��d��/���!���q_i����;UKC�����z�Ek�+���a\��8$�lj�l�թ�p�IsXt�DvUpU�~��`��>�
2
- G���ʲA���%bD�����[��
1
+ 4Ph�<U=�ע�,|�I�}�Dm�0�0�y&���p���cZ!��th�j��z�� iTlð|<������i~y�zJ����8�3.�(f��BIL
2
+ �tbN�H'�M2�4�?6� ߂;����F�ʅL !-p�)���Rn����Nb5�Z5(~1� ����)A��\�O!,{�^�?H��Z�J�Щ�C���:�$l����(G�;.��KZ�=�������g�Ô�I��e`�7FױM��ۚ��"^2@p�CS7�J� ^6#��1*
metadata CHANGED
@@ -1,13 +1,13 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: sexp_processor
3
3
  version: !ruby/object:Gem::Version
4
- hash: 59
4
+ hash: 57
5
5
  prerelease:
6
6
  segments:
7
7
  - 4
8
8
  - 1
9
- - 0
10
- version: 4.1.0
9
+ - 1
10
+ version: 4.1.1
11
11
  platform: ruby
12
12
  authors:
13
13
  - Ryan Davis
@@ -36,7 +36,7 @@ cert_chain:
36
36
  FBHgymkyj/AOSqKRIpXPhjC6
37
37
  -----END CERTIFICATE-----
38
38
 
39
- date: 2012-10-22 00:00:00 Z
39
+ date: 2012-11-02 00:00:00 Z
40
40
  dependencies:
41
41
  - !ruby/object:Gem::Dependency
42
42
  name: minitest
metadata.gz.sig CHANGED
Binary file