spec/parser_spec.rb in nydp-0.0.2 vs spec/parser_spec.rb in nydp-0.0.3

@@ -1,10 +1,8 @@
 require 'spec_helper'
 
 describe Nydp::Parser do
-
-  let(:ns)               { { } }
   let(:aa)               { Nydp::Symbol.mk :aa,                   ns }
   let(:a)                { Nydp::Symbol.mk :a,                    ns }
   let(:b)                { Nydp::Symbol.mk :b,                    ns }
   let(:c)                { Nydp::Symbol.mk :c,                    ns }
   let(:d)                { Nydp::Symbol.mk :d,                    ns }
@@ -19,22 +17,10 @@
   let(:comment)          { Nydp::Symbol.mk :comment,              ns }
   let(:dotsyn)           { Nydp::Symbol.mk :"dot-syntax",         ns }
   let(:cocosyn)          { Nydp::Symbol.mk :"colon-colon-syntax", ns }
   let(:colosyn)          { Nydp::Symbol.mk :"colon-syntax",       ns }
 
-  def sym name
-    Nydp::Symbol.mk name.to_sym, ns
-  end
-
-  def parse txt
-    Nydp::Parser.new(ns).expression(Nydp::Tokeniser.new txt)
-  end
-
-  def pair_list xs, last=Nydp.NIL
-    Nydp::Pair.from_list xs, last
-  end
-
   it "should return a stream of tokens" do
     t = Nydp::Tokeniser.new ""
     expect(t.next_token).to eq nil
   end
 
@@ -118,15 +104,29 @@
     expected = pair_list [x1, x2, x3]
 
     expect(parse '(1 "hello there \"jimmy\"" 3)').to eq expected
   end
 
+  it "should handle escaped tabs and newlines inside a string" do
+    expected = Nydp::StringAtom.new "hello\tworld\nnice day"
+    parsed = parse "\"hello\\tworld\\nnice day\""
+    expect(parsed).to eq expected
+  end
+
+  it "should parse a brace list" do
+    expect(parse "{a b c d}").to eq pair_list [sym("brace-list"), a, b, c, d]
+  end
+
   it "should parse a plain symbol" do
     expect(parse "foo").to eq foo
   end
 
   it "should parse a dotted symbol" do
     expect(parse "foo.bar").to eq  pair_list([dotsyn, foo, bar])
+  end
+
+  it "should parse a dotted symbol" do
+    expect(parse "(list a b foo.bar c)").to eq  pair_list([sym(:list), a, b, pair_list([dotsyn, foo, bar]), c])
   end
 
   it "should parse a colon-colon symbol" do
     expect(parse "foo::bar").to eq  pair_list([cocosyn, foo, bar])
   end