RubyGems - ripper_ruby_parser - Versions diffs - 1.7.2 → 1.10.0 - Mend

ripper_ruby_parser 1.7.2 → 1.10.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 (48) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +50 -0
data/README.md +4 -4
data/lib/ripper_ruby_parser/commenting_ripper_parser.rb +24 -12
data/lib/ripper_ruby_parser/sexp_handlers/assignment.rb +2 -2
data/lib/ripper_ruby_parser/sexp_handlers/blocks.rb +47 -53
data/lib/ripper_ruby_parser/sexp_handlers/conditionals.rb +17 -19
data/lib/ripper_ruby_parser/sexp_handlers/helper_methods.rb +34 -1
data/lib/ripper_ruby_parser/sexp_handlers/literals.rb +1 -1
data/lib/ripper_ruby_parser/sexp_handlers/method_calls.rb +9 -5
data/lib/ripper_ruby_parser/sexp_handlers/methods.rb +17 -15
data/lib/ripper_ruby_parser/sexp_handlers/operators.rb +3 -3
data/lib/ripper_ruby_parser/sexp_handlers/string_literals.rb +24 -28
data/lib/ripper_ruby_parser/sexp_processor.rb +5 -18
data/lib/ripper_ruby_parser/unescape.rb +63 -22
data/lib/ripper_ruby_parser/version.rb +1 -1
metadata +140 -79
data/Rakefile +0 -33
data/test/end_to_end/comments_test.rb +0 -59
data/test/end_to_end/comparison_test.rb +0 -104
data/test/end_to_end/lib_comparison_test.rb +0 -18
data/test/end_to_end/line_numbering_test.rb +0 -31
data/test/end_to_end/samples_comparison_test.rb +0 -13
data/test/end_to_end/test_comparison_test.rb +0 -18
data/test/pt_testcase/pt_test.rb +0 -44
data/test/ripper_ruby_parser/commenting_ripper_parser_test.rb +0 -200
data/test/ripper_ruby_parser/parser_test.rb +0 -576
data/test/ripper_ruby_parser/sexp_handlers/assignment_test.rb +0 -597
data/test/ripper_ruby_parser/sexp_handlers/blocks_test.rb +0 -717
data/test/ripper_ruby_parser/sexp_handlers/conditionals_test.rb +0 -536
data/test/ripper_ruby_parser/sexp_handlers/literals_test.rb +0 -165
data/test/ripper_ruby_parser/sexp_handlers/loops_test.rb +0 -209
data/test/ripper_ruby_parser/sexp_handlers/method_calls_test.rb +0 -237
data/test/ripper_ruby_parser/sexp_handlers/methods_test.rb +0 -429
data/test/ripper_ruby_parser/sexp_handlers/operators_test.rb +0 -405
data/test/ripper_ruby_parser/sexp_handlers/string_literals_test.rb +0 -973
data/test/ripper_ruby_parser/sexp_processor_test.rb +0 -327
data/test/ripper_ruby_parser/version_test.rb +0 -7
data/test/samples/assignment.rb +0 -22
data/test/samples/comments.rb +0 -13
data/test/samples/conditionals.rb +0 -23
data/test/samples/lambdas.rb +0 -5
data/test/samples/loops.rb +0 -36
data/test/samples/misc.rb +0 -285
data/test/samples/number.rb +0 -9
data/test/samples/operators.rb +0 -18
data/test/samples/strings.rb +0 -147
data/test/test_helper.rb +0 -111

data/test/ripper_ruby_parser/sexp_handlers/conditionals_test.rb DELETED Viewed

@@ -1,536 +0,0 @@
-# frozen_string_literal: true
-require File.expand_path("../../test_helper.rb", File.dirname(__FILE__))
-describe RipperRubyParser::Parser do
-  describe "#parse" do
-    describe "for regular if" do
-      it "works with a single statement" do
-        _("if foo; bar; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               nil)
-      end
-      it "works with multiple statements" do
-        _("if foo; bar; baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:block,
-                                 s(:call, nil, :bar),
-                                 s(:call, nil, :baz)),
-                               nil)
-      end
-      it "works with zero statements" do
-        _("if foo; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               nil,
-                               nil)
-      end
-      it "works with a begin..end block" do
-        _("if foo; begin; bar; end; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               nil)
-      end
-      it "works with an else clause" do
-        _("if foo; bar; else; baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:call, nil, :baz))
-      end
-      it "works with an empty main clause" do
-        _("if foo; else; bar; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               nil,
-                               s(:call, nil, :bar))
-      end
-      it "works with an empty else clause" do
-        _("if foo; bar; else; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               nil)
-      end
-      it "handles a negative condition correctly" do
-        _("if not foo; bar; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, s(:call, nil, :foo), :!),
-                               s(:call, nil, :bar),
-                               nil)
-      end
-      it "handles bare integer literal in condition" do
-        _("if 1; bar; end")
-          .must_be_parsed_as s(:if,
-                               s(:lit, 1),
-                               s(:call, nil, :bar),
-                               nil)
-      end
-      it "handles bare regex literal in condition" do
-        _("if /foo/; bar; end")
-          .must_be_parsed_as s(:if,
-                               s(:match, s(:lit, /foo/)),
-                               s(:call, nil, :bar),
-                               nil)
-      end
-      it "handles interpolated regex in condition" do
-        _('if /#{foo}/; bar; end')
-          .must_be_parsed_as s(:if,
-                               s(:dregx, "", s(:evstr, s(:call, nil, :foo))),
-                               s(:call, nil, :bar),
-                               nil)
-      end
-      it "handles block conditions" do
-        _("if (foo; bar); baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:block, s(:call, nil, :foo), s(:call, nil, :bar)),
-                               s(:call, nil, :baz),
-                               nil)
-      end
-      it "converts :dot2 to :flip2" do
-        _("if foo..bar; baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:flip2, s(:call, nil, :foo), s(:call, nil, :bar)),
-                               s(:call, nil, :baz),
-                               nil)
-      end
-      it "converts :dot3 to :flip3" do
-        _("if foo...bar; baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:flip3, s(:call, nil, :foo), s(:call, nil, :bar)),
-                               s(:call, nil, :baz),
-                               nil)
-      end
-      it "handles negative match operator" do
-        _("if foo !~ bar; baz; else; qux; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
-                               s(:call, nil, :qux),
-                               s(:call, nil, :baz))
-      end
-      it "cleans up begin..end block in condition" do
-        _("if begin foo end; bar; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar), nil)
-      end
-      it "handles special conditions inside begin..end block" do
-        _("if begin foo..bar end; baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:flip2, s(:call, nil, :foo), s(:call, nil, :bar)),
-                               s(:call, nil, :baz),
-                               nil)
-      end
-      it "works with assignment in the condition" do
-        _("if foo = bar; baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:lasgn, :foo,
-                                 s(:call, nil, :bar)),
-                               s(:call, nil, :baz), nil)
-      end
-      it "works with bracketed assignment in the condition" do
-        _("if (foo = bar); baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:lasgn, :foo,
-                                 s(:call, nil, :bar)),
-                               s(:call, nil, :baz), nil)
-      end
-    end
-    describe "for postfix if" do
-      it "works with a simple condition" do
-        _("foo if bar")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :bar),
-                               s(:call, nil, :foo),
-                               nil)
-      end
-      it "handles negative conditions" do
-        _("foo if not bar")
-          .must_be_parsed_as s(:if,
-                               s(:call, s(:call, nil, :bar), :!),
-                               s(:call, nil, :foo),
-                               nil)
-      end
-      it "handles bare regex literal in condition" do
-        _("foo if /bar/")
-          .must_be_parsed_as s(:if,
-                               s(:match, s(:lit, /bar/)),
-                               s(:call, nil, :foo),
-                               nil)
-      end
-      it "handles interpolated regex in condition" do
-        _('foo if /#{bar}/')
-          .must_be_parsed_as s(:if,
-                               s(:dregx, "", s(:evstr, s(:call, nil, :bar))),
-                               s(:call, nil, :foo),
-                               nil)
-      end
-      it "handles negative match operator" do
-        _("baz if foo !~ bar")
-          .must_be_parsed_as s(:if,
-                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
-                               nil,
-                               s(:call, nil, :baz))
-      end
-      it "cleans up begin..end block in condition" do
-        _("foo if begin bar end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :bar),
-                               s(:call, nil, :foo), nil)
-      end
-    end
-    describe "for regular unless" do
-      it "works with a single statement" do
-        _("unless bar; foo; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :bar),
-                               nil,
-                               s(:call, nil, :foo))
-      end
-      it "works with multiple statements" do
-        _("unless foo; bar; baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               nil,
-                               s(:block,
-                                 s(:call, nil, :bar),
-                                 s(:call, nil, :baz)))
-      end
-      it "works with zero statements" do
-        _("unless foo; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               nil,
-                               nil)
-      end
-      it "works with an else clause" do
-        _("unless foo; bar; else; baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :baz),
-                               s(:call, nil, :bar))
-      end
-      it "works with an empty main clause" do
-        _("unless foo; else; bar; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               nil)
-      end
-      it "works with an empty else block" do
-        _("unless foo; bar; else; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               nil,
-                               s(:call, nil, :bar))
-      end
-      it "handles bare regex literal in condition" do
-        _("unless /foo/; bar; end")
-          .must_be_parsed_as s(:if,
-                               s(:match, s(:lit, /foo/)),
-                               nil,
-                               s(:call, nil, :bar))
-      end
-      it "handles interpolated regex in condition" do
-        _('unless /#{foo}/; bar; end')
-          .must_be_parsed_as s(:if,
-                               s(:dregx, "", s(:evstr, s(:call, nil, :foo))),
-                               nil,
-                               s(:call, nil, :bar))
-      end
-      it "handles negative match operator" do
-        _("unless foo !~ bar; baz; else; qux; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
-                               s(:call, nil, :baz),
-                               s(:call, nil, :qux))
-      end
-    end
-    describe "for postfix unless" do
-      it "works with a simple condition" do
-        _("foo unless bar")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :bar),
-                               nil,
-                               s(:call, nil, :foo))
-      end
-      it "handles bare regex literal in condition" do
-        _("foo unless /bar/")
-          .must_be_parsed_as s(:if,
-                               s(:match, s(:lit, /bar/)),
-                               nil,
-                               s(:call, nil, :foo))
-      end
-      it "handles interpolated regex in condition" do
-        _('foo unless /#{bar}/')
-          .must_be_parsed_as s(:if,
-                               s(:dregx, "", s(:evstr, s(:call, nil, :bar))),
-                               nil,
-                               s(:call, nil, :foo))
-      end
-      it "handles negative match operator" do
-        _("baz unless foo !~ bar")
-          .must_be_parsed_as s(:if,
-                               s(:call, s(:call, nil, :foo), :=~, s(:call, nil, :bar)),
-                               s(:call, nil, :baz),
-                               nil)
-      end
-    end
-    describe "for elsif" do
-      it "works with a single statement" do
-        _("if foo; bar; elsif baz; qux; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:if,
-                                 s(:call, nil, :baz),
-                                 s(:call, nil, :qux),
-                                 nil))
-      end
-      it "works with an empty consequesnt" do
-        _("if foo; bar; elsif baz; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:if,
-                                 s(:call, nil, :baz),
-                                 nil,
-                                 nil))
-      end
-      it "works with an else" do
-        _("if foo; bar; elsif baz; qux; else; quuz; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:if,
-                                 s(:call, nil, :baz),
-                                 s(:call, nil, :qux),
-                                 s(:call, nil, :quuz)))
-      end
-      it "works with an empty else" do
-        _("if foo; bar; elsif baz; qux; else; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:if,
-                                 s(:call, nil, :baz),
-                                 s(:call, nil, :qux),
-                                 nil))
-      end
-      it "handles a negative condition correctly" do
-        _("if foo; bar; elsif not baz; qux; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:if,
-                                 s(:call, s(:call, nil, :baz), :!),
-                                 s(:call, nil, :qux), nil))
-      end
-      it "does not replace :dot2 with :flip2" do
-        _("if foo; bar; elsif baz..qux; quuz; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:if,
-                                 s(:dot2, s(:call, nil, :baz), s(:call, nil, :qux)),
-                                 s(:call, nil, :quuz), nil))
-      end
-      it "does not rewrite the negative match operator" do
-        _("if foo; bar; elsif baz !~ qux; quuz; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:if,
-                                 s(:not,
-                                   s(:call,
-                                     s(:call, nil, :baz),
-                                     :=~,
-                                     s(:call, nil, :qux))),
-                                 s(:call, nil, :quuz),
-                                 nil))
-      end
-      it "cleans up begin..end block in condition" do
-        _("if foo; bar; elsif begin baz end; qux; end")
-          .must_be_parsed_as s(:if,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:if,
-                                 s(:call, nil, :baz),
-                                 s(:call, nil, :qux),
-                                 nil))
-      end
-    end
-    describe "for case block" do
-      it "works with a single when clause" do
-        _("case foo; when bar; baz; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array, s(:call, nil, :bar)),
-                                 s(:call, nil, :baz)),
-                               nil)
-      end
-      it "works with multiple when clauses" do
-        _("case foo; when bar; baz; when qux; quux; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array, s(:call, nil, :bar)),
-                                 s(:call, nil, :baz)),
-                               s(:when,
-                                 s(:array, s(:call, nil, :qux)),
-                                 s(:call, nil, :quux)),
-                               nil)
-      end
-      it "works with multiple statements in the when block" do
-        _("case foo; when bar; baz; qux; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array, s(:call, nil, :bar)),
-                                 s(:call, nil, :baz),
-                                 s(:call, nil, :qux)),
-                               nil)
-      end
-      it "works with an else clause" do
-        _("case foo; when bar; baz; else; qux; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array, s(:call, nil, :bar)),
-                                 s(:call, nil, :baz)),
-                               s(:call, nil, :qux))
-      end
-      it "works with multiple statements in the else block" do
-        _("case foo; when bar; baz; else; qux; quuz end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array,
-                                   s(:call, nil, :bar)),
-                                 s(:call, nil, :baz)),
-                               s(:block,
-                                 s(:call, nil, :qux),
-                                 s(:call, nil, :quuz)))
-      end
-      it "works with an empty when block" do
-        _("case foo; when bar; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when, s(:array, s(:call, nil, :bar)), nil),
-                               nil)
-      end
-      it "works with an empty else block" do
-        _("case foo; when bar; baz; else; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array, s(:call, nil, :bar)),
-                                 s(:call, nil, :baz)),
-                               nil)
-      end
-      it "works with a splat in the when clause" do
-        _("case foo; when *bar; baz; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array,
-                                   s(:splat, s(:call, nil, :bar))),
-                                 s(:call, nil, :baz)),
-                               nil)
-      end
-      it "cleans up a multi-statement begin..end in the when clause" do
-        _("case foo; when bar; begin; baz; qux; end; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array, s(:call, nil, :bar)),
-                                 s(:call, nil, :baz),
-                                 s(:call, nil, :qux)),
-                               nil)
-      end
-      it "cleans up a multi-statement begin..end at start of the when clause" do
-        _("case foo; when bar; begin; baz; qux; end; quuz; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array, s(:call, nil, :bar)),
-                                 s(:call, nil, :baz),
-                                 s(:call, nil, :qux),
-                                 s(:call, nil, :quuz)),
-                               nil)
-      end
-      it "keeps up a multi-statement begin..end in the else clause" do
-        _("case foo; when bar; baz; else; begin; qux; quuz; end; end")
-          .must_be_parsed_as s(:case,
-                               s(:call, nil, :foo),
-                               s(:when,
-                                 s(:array, s(:call, nil, :bar)),
-                                 s(:call, nil, :baz)),
-                               s(:block,
-                                 s(:call, nil, :qux),
-                                 s(:call, nil, :quuz)))
-      end
-    end
-  end
-end

data/test/ripper_ruby_parser/sexp_handlers/literals_test.rb DELETED Viewed

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-require File.expand_path("../../test_helper.rb", File.dirname(__FILE__))
-describe RipperRubyParser::Parser do
-  let(:parser) { RipperRubyParser::Parser.new }
-  describe "#parse" do
-    describe "for character literals" do
-      it "works for simple character literals" do
-        _("?a")
-          .must_be_parsed_as s(:str, "a")
-      end
-      it "works for escaped character literals" do
-        _('?\\n')
-          .must_be_parsed_as s(:str, "\n")
-      end
-      it "works for escaped character literals with ctrl" do
-        _('?\\C-a')
-          .must_be_parsed_as s(:str, "\u0001")
-      end
-      it "works for escaped character literals with meta" do
-        _('?\\M-a')
-          .must_be_parsed_as s(:str, (+"\xE1").force_encoding("ascii-8bit"))
-      end
-      it "works for escaped character literals with meta plus shorthand ctrl" do
-        _('?\\M-\\ca')
-          .must_be_parsed_as s(:str, (+"\x81").force_encoding("ascii-8bit"))
-      end
-      it "works for escaped character literals with shorthand ctrl plus meta" do
-        _('?\\c\\M-a')
-          .must_be_parsed_as s(:str, (+"\x81").force_encoding("ascii-8bit"))
-      end
-      it "works for escaped character literals with meta plus ctrl" do
-        _('?\\M-\\C-a')
-          .must_be_parsed_as s(:str, (+"\x81").force_encoding("ascii-8bit"))
-      end
-      it "works for escaped character literals with ctrl plus meta" do
-        _('?\\C-\\M-a')
-          .must_be_parsed_as s(:str, (+"\x81").force_encoding("ascii-8bit"))
-      end
-    end
-    describe "for array literals" do
-      it "works for an empty array" do
-        _("[]")
-          .must_be_parsed_as s(:array)
-      end
-      it "works for a simple case with splat" do
-        _("[*foo]")
-          .must_be_parsed_as s(:array,
-                               s(:splat, s(:call, nil, :foo)))
-      end
-      it "works for a multi-element case with splat" do
-        _("[foo, *bar]")
-          .must_be_parsed_as s(:array,
-                               s(:call, nil, :foo),
-                               s(:splat, s(:call, nil, :bar)))
-      end
-    end
-    describe "for hash literals" do
-      it "works for an empty hash" do
-        _("{}")
-          .must_be_parsed_as s(:hash)
-      end
-      it "works for a hash with one pair" do
-        _("{foo => bar}")
-          .must_be_parsed_as s(:hash,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar))
-      end
-      it "works for a hash with multiple pairs" do
-        _("{foo => bar, baz => qux}")
-          .must_be_parsed_as s(:hash,
-                               s(:call, nil, :foo),
-                               s(:call, nil, :bar),
-                               s(:call, nil, :baz),
-                               s(:call, nil, :qux))
-      end
-      it "works for a hash with label keys" do
-        _("{foo: bar, baz: qux}")
-          .must_be_parsed_as s(:hash,
-                               s(:lit, :foo),
-                               s(:call, nil, :bar),
-                               s(:lit, :baz),
-                               s(:call, nil, :qux))
-      end
-      it "works for a hash with dynamic label keys" do
-        _("{'foo': bar}")
-          .must_be_parsed_as s(:hash,
-                               s(:lit, :foo),
-                               s(:call, nil, :bar))
-      end
-      it "works for a hash with splat" do
-        _("{foo: bar, baz: qux, **quux}")
-          .must_be_parsed_as s(:hash,
-                               s(:lit, :foo), s(:call, nil, :bar),
-                               s(:lit, :baz), s(:call, nil, :qux),
-                               s(:kwsplat, s(:call, nil, :quux)))
-      end
-    end
-    describe "for number literals" do
-      it "works for floats" do
-        _("3.14")
-          .must_be_parsed_as s(:lit, 3.14)
-      end
-      it "works for octal integer literals" do
-        _("0700")
-          .must_be_parsed_as s(:lit, 448)
-      end
-      it "handles negative sign for integers" do
-        _("-1")
-          .must_be_parsed_as s(:lit, -1)
-      end
-      it "handles space after negative sign for integers" do
-        _("-1 ")
-          .must_be_parsed_as s(:lit, -1)
-      end
-      it "handles negative sign for floats" do
-        _("-3.14")
-          .must_be_parsed_as s(:lit, -3.14)
-      end
-      it "handles space after negative sign for floats" do
-        _("-3.14 ")
-          .must_be_parsed_as s(:lit, -3.14)
-      end
-      it "handles positive sign" do
-        _("+1")
-          .must_be_parsed_as s(:lit, 1)
-      end
-      it "works for rationals" do
-        _("1000r")
-          .must_be_parsed_as s(:lit, 1000r)
-      end
-      it "works for imaginary numbers" do
-        _("1i")
-          .must_be_parsed_as s(:lit, 1i)
-      end
-    end
-  end
-end