rouge-lang 0.0.1

data/spec/metadata_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::Metadata do
+  before do
+    @class = Class.new do
+      include Rouge::Metadata
+    end
+  end
+
+  describe "the metadata accessors" do
+    it "should be present on class instances" do
+      @class.new.should respond_to(:meta).with(0).arguments
+      @class.new.should respond_to(:meta=).with(1).argument
+    end
+
+    it "should default to nil" do
+      @class.new.meta.should be_nil
+    end
+
+    it "should return the new value when set" do
+      i = @class.new
+      i.meta = {:x => 4}
+      i.meta.to_s.should eq({:x => 4}.to_s)
+    end
+
+    it "should not allow being set to anything other than a Hash or nil" do
+      lambda {
+        @class.new.meta = {:a => 1}
+        @class.new.meta = {}
+        @class.new.meta = {1 => 2, 3 => 4, 5 => {}}
+        @class.new.meta = nil
+      }.should_not raise_exception
+
+      lambda {
+        @class.new.meta = 4
+      }.should raise_exception(Rouge::Metadata::InvalidMetadataError)
+
+      lambda {
+        @class.new.meta = true
+      }.should raise_exception(Rouge::Metadata::InvalidMetadataError)
+
+      lambda {
+        @class.new.meta = Rouge::Symbol[:blah]
+      }.should raise_exception(Rouge::Metadata::InvalidMetadataError)
+
+      lambda {
+        @class.new.meta = []
+      }.should raise_exception(Rouge::Metadata::InvalidMetadataError)
+
+      lambda {
+        @class.new.meta = Rouge::Seq::Cons["what"]
+      }.should raise_exception(Rouge::Metadata::InvalidMetadataError)
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/spec/namespace_spec.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::Namespace do
+  describe "the [] method" do
+    it "should vivify non-extant namespaces" do
+      Rouge::Namespace.exists?(:vivify_test).should eq false
+      Rouge::Namespace[:vivify_test].should be_an_instance_of Rouge::Namespace
+      Rouge::Namespace.exists?(:vivify_test).should eq true
+    end
+  end
+
+  describe "the Rouge[] shortcut" do
+    it "should directly call the [] method" do
+      Rouge::Namespace.should_receive(:[]).with(:trazzle)
+      Rouge[:trazzle]
+    end
+  end
+
+  describe "the set_here method" do
+    it "should create a var for the name, assigning the root to the value" do
+      w = Rouge::Namespace.new :w
+      w.set_here :waldorf, "Yes!"
+      w[:waldorf].should eq Rouge::Var.new(:w, :waldorf, "Yes!")
+    end
+  end
+
+  describe "the intern method" do
+    it "should create an unbound var for the name if it doesn't exist" do
+      m = Rouge::Namespace.new :m
+      m.intern :connor
+      m[:connor].should eq Rouge::Var.new(:m, :connor)
+    end
+
+    it "should do nothing if the var already exists" do
+      q = Rouge::Namespace.new :q
+      q.set_here :matthias, 50
+      q.intern :matthias
+      q[:matthias].should eq Rouge::Var.new(:q, :matthias, 50)
+    end
+  end
+
+  describe "the refer method" do
+    it "should cause items in one namespace to be locatable from the other" do
+      abc = Rouge::Namespace.new :abc
+      xyz = Rouge::Namespace.new :xyz
+
+      xyz.refer abc
+
+      abc.set_here :hello, :wow
+      xyz[:hello].deref.should eq :wow
+    end
+
+    it "may not be used to refer namespaces to themselves" do
+      lambda {
+        Rouge[:user].refer Rouge[:user]
+      }.should raise_exception(Rouge::Namespace::RecursiveNamespaceError)
+    end
+  end
+
+  describe "the destroy method" do
+    it "should obliterate a namespace" do
+      Rouge[:"user.spec2"].set_here :nope, :ok
+      Rouge::Namespace.destroy :"user.spec2"
+      lambda {
+        Rouge[:"user.spec2"][:nope]
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+    end
+  end
+
+  describe "the rouge.builtin namespace" do
+    before do
+      @ns = Rouge[:"rouge.builtin"]
+    end
+
+    it "should contain elements from Rouge::Builtins" do
+      @ns[:let].deref.should be_an_instance_of Rouge::Builtin
+      @ns[:quote].deref.should be_an_instance_of Rouge::Builtin
+    end
+
+    it "should not find objects from ruby" do
+      lambda {
+        @ns[:Float]
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+      lambda {
+        @ns[:String]
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+    end
+
+    it "should have a name" do
+      @ns.name.should eq :"rouge.builtin"
+    end
+  end
+
+  describe "the ruby namespace" do
+    before do
+      @ns = Rouge::Namespace[:ruby]
+    end
+
+    it "should contain elements from Kernel" do
+      @ns[:Hash].should eq Rouge::Var.new(:ruby, :Hash, Hash)
+      @ns[:Fixnum].should eq Rouge::Var.new(:ruby, :Fixnum, Fixnum)
+    end
+
+    it "should contain global variables" do
+      @ns[:"$LOAD_PATH"].
+          should eq Rouge::Var.new(:ruby, :$LOAD_PATH, $LOAD_PATH)
+    end
+
+    it "should have a name" do
+      @ns.name.should eq :ruby
+    end
+  end
+
+  describe "the read method" do
+    it "should read input in this namespace" do
+      Rouge::Namespace[:xyz].read("`ham").
+          should eq Rouge::Seq::Cons[Rouge::Symbol[:quote],
+                                Rouge::Symbol[:"xyz/ham"]]
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/spec/printer_spec.rb

@@ -0,0 +1,191 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::Printer do
+  describe ".print" do
+    context "numbers" do
+      it { Rouge.print(12755, "").should eq "12755" }
+    end
+
+    context "symbols" do
+      it { Rouge.print(Rouge::Symbol[:loki], "").should eq "loki" }
+      it { Rouge.print(Rouge::Symbol[:/], "").should eq "/" }
+      it { Rouge.print(Rouge::Symbol[:wah?], "").should eq "wah?" }
+      it { Rouge.print(Rouge::Symbol[:"!ruby!"], "").should eq "!ruby!" }
+      it { Rouge.print(Rouge::Symbol[:nil], "").should eq "nil" }
+      it { Rouge.print(Rouge::Symbol[:true], "").should eq "true" }
+      it { Rouge.print(Rouge::Symbol[:false], "").should eq "false" }
+    end
+
+    context "keywords" do
+      context "plain keywords" do
+        it { Rouge.print(:loki, "").should eq ":loki" }
+        it { Rouge.print(:/, "").should eq ":/" }
+        it { Rouge.print(:wah?, "").should eq ":wah?" }
+        it { Rouge.print(:nil, "").should eq ":nil" }
+        it { Rouge.print(:true, "").should eq ":true" }
+        it { Rouge.print(:false, "").should eq ":false" }
+      end
+
+      context "string-symbols" do
+        it { Rouge.print(:"!ruby!", "").should eq ":\"!ruby!\"" }
+      end
+    end
+
+    context "strings" do
+      context "plain strings" do
+        it { Rouge.print("akashi yo", "").should eq "\"akashi yo\"" }
+        it { Rouge.print("akashi\nwoah!", "").should eq "\"akashi\\nwoah!\"" }
+      end
+
+      context "escape sequences" do
+        it { Rouge.print("here \" goes", "").should eq "\"here \\\" goes\"" }
+        it { Rouge.print("here \\ goes", "").should eq "\"here \\\\ goes\"" }
+        it { Rouge.print("\a\b\e\f\n", "").should eq "\"\\a\\b\\e\\f\\n\"" }
+        it { Rouge.print("\r\t\v", "").should eq "\"\\r\\t\\v\"" }
+      end
+    end
+
+    context "lists" do
+      context "empty list" do
+        it { Rouge.print(Rouge::Seq::Cons[], "").should eq "()" }
+      end
+
+      context "one-element lists" do
+        it { Rouge.print(Rouge::Seq::Cons[Rouge::Symbol[:tiffany]], "").
+                 should eq "(tiffany)" }
+        it { Rouge.print(Rouge::Seq::Cons[:raaaaash], "").
+                 should eq "(:raaaaash)" }
+      end
+
+      context "multiple-element lists" do
+        it { Rouge.print(Rouge::Seq::Cons[1, 2, 3], "").should eq "(1 2 3)" }
+        it { Rouge.print(Rouge::Seq::Cons[Rouge::Symbol[:true],
+                                          Rouge::Seq::Cons[], [], "no"], "").
+                 should eq "(true () [] \"no\")" }
+      end
+
+      context "nested lists" do
+        it { Rouge.print(
+                 Rouge::Seq::Cons[
+                     Rouge::Seq::Cons[Rouge::Seq::Cons[3],
+                                      Rouge::Seq::Cons[Rouge::Seq::Cons[]]],
+                     9,
+                     Rouge::Seq::Cons[Rouge::Seq::Cons[8],
+                                      Rouge::Seq::Cons[8]]],
+                 "").
+                 should eq "(((3) (())) 9 ((8) (8)))" }
+      end
+    end
+
+    context "vectors" do
+      context "the empty vector" do
+        it { Rouge.print([], "").should eq "[]" }
+      end
+
+      context "one-element vectors" do
+        it { Rouge.print([Rouge::Symbol[:tiffany]], "").should eq "[tiffany]" }
+        it { Rouge.print([:raaaaash], "").should eq "[:raaaaash]" }
+      end
+
+      context "multiple-element vectors" do
+        it { Rouge.print([1, 2, 3], "").should eq "[1 2 3]" }
+        it { Rouge.print([Rouge::Symbol[:true], Rouge::Seq::Cons[], [], "no"], "").
+                 should eq "[true () [] \"no\"]" }
+      end
+
+      context "nested vectors" do
+        it { Rouge.print([[[3], [[]]], 9, [[8], [8]]], "").
+                 should eq "[[[3] [[]]] 9 [[8] [8]]]" }
+      end
+    end
+
+    context "quotations" do
+      it { Rouge.print(
+               Rouge::Seq::Cons[Rouge::Symbol[:quote], Rouge::Symbol[:x]],
+               "").
+               should eq "'x" }
+      it { Rouge.print(Rouge::Seq::Cons[Rouge::Symbol[:quote],
+                       Rouge::Seq::Cons[Rouge::Symbol[:quote],
+                       Rouge::Seq::Cons[Rouge::Seq::Cons[Rouge::Symbol[:quote],
+                       Rouge::Symbol[:x]]]]], "").
+               should eq "''('x)" }
+    end
+
+    context "vars" do
+      it { Rouge.print(Rouge::Seq::Cons[Rouge::Symbol[:var],
+                                        Rouge::Symbol[:"x/y"]], "").
+               should eq "#'x/y" }
+
+      it { Rouge.print(Rouge::Seq::Cons[Rouge::Symbol[:var],
+                       Rouge::Seq::Cons[Rouge::Symbol[:var],
+                       Rouge::Seq::Cons[Rouge::Seq::Cons[Rouge::Symbol[:var],
+                       Rouge::Symbol[:"x/y"]]]]], "").
+               should eq "#'#'(#'x/y)" }
+
+      it { Rouge.print(Rouge::Var.new(:x, :y), "").should eq "#'x/y" }
+    end
+
+    context "maps" do
+      context "the empty map" do
+        it { Rouge.print({}, "").should eq "{}" }
+      end
+
+      context "one-element maps" do
+        it { Rouge.print({Rouge::Symbol[:a] => 1}, "").should eq "{a 1}" }
+        it { Rouge.print({"quux" => [Rouge::Symbol[:lambast]]}, "").
+                 should eq "{\"quux\" [lambast]}" }
+      end
+
+      context "multiple-element maps" do
+        # XXX(arlen): these tests rely on stable-ish Hash order
+        it { Rouge.print({:a => 1, :b => 2}, "").should eq "{:a 1, :b 2}" }
+        it { Rouge.print({:f => :f, :y => :y, :z => :z}, "").
+                 should eq "{:f :f, :y :y, :z :z}" }
+      end
+
+      context "nested maps" do
+        # XXX(arlen): this test relies on stable-ish Hash order
+        it { Rouge.print({:a => {:z => 9},
+                          :b => {:q => Rouge::Symbol[:q]}}, "").
+                 should eq "{:a {:z 9}, :b {:q q}}" }
+        it { Rouge.print({{9 => 7} => 5}, "").should eq "{{9 7} 5}" }
+      end
+    end
+
+    context "fundamental objects" do
+      it { Rouge.print(nil, "").should eq "nil" }
+      it { Rouge.print(true, "").should eq "true" }
+      it { Rouge.print(false, "").should eq "false" }
+    end
+
+    context "Ruby classes" do
+      it { Rouge.print(Object, "").should eq "ruby/Object" }
+      it { Rouge.print(Class, "").should eq "ruby/Class" }
+      it { Rouge.print(Rouge::Context, "").should eq "ruby/Rouge.Context" }
+
+      let(:anon) { Class.new }
+      it { Rouge.print(anon, "").should eq anon.inspect }
+    end
+
+    context "builtin forms" do
+      it { Rouge.print(Rouge::Builtin[Rouge::Builtins.method(:let)], "").
+               should eq "rouge.builtin/let" }
+      it { Rouge.print(Rouge::Builtin[Rouge::Builtins.method(:def)], "").
+               should eq "rouge.builtin/def" }
+    end
+
+    context "unknown forms" do
+      let(:l) { lambda {} }
+      it { Rouge.print(l, "").should eq l.inspect }
+    end
+
+    context "regexp" do
+      let(:rx) { Regexp.new("abc") }
+      it { Rouge.print(rx, "").should eq "#\"abc\"" }
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/spec/reader_spec.rb

@@ -0,0 +1,422 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::Reader do
+  before do
+    @ns = Rouge[:"user.spec"].clear
+    @ns.refer Rouge[:"rouge.builtin"]
+  end
+
+  describe "reading numbers" do
+    it { @ns.read("12755").should eq 12755 }
+    it { @ns.read("2_50_9").should eq 2509 }
+    it { @ns.read("-999").should eq(-999) }
+    it { @ns.read("+1704").should eq(1704) }
+
+    context "floats" do
+      it { @ns.read("23.0").should be_an_instance_of Float }
+      it { @ns.read("23.0").should eq 23.0 }
+      it { @ns.read("23.1").should eq 23.1 }
+      it { @ns.read("-23.1").should eq(-23.1) }
+      it { @ns.read("+17.04").should eq(17.04) }
+      it { @ns.read("+1_000e-3").should eq(1.0) }
+      it { @ns.read("+1E+3").should eq(1000) }
+    end
+
+    context "binary" do
+      it { @ns.read("+0b10").should eq(2) }
+      it { @ns.read("-0b10").should eq(-2) }
+    end
+
+    context "hexadecimal" do
+      it { @ns.read("+0xf").should eq(15) }
+      it { @ns.read("-0xf").should eq(-15) }
+    end
+
+    context "octal" do
+      it { @ns.read("+0333").should eq(219) }
+      it { @ns.read("-0333").should eq(-219) }
+    end
+
+    it "should fail on invalid numbers" do
+      lambda { @ns.read("1.2.3") }.should raise_exception(Rouge::Reader::UnexpectedCharacterError)
+      lambda { @ns.read("12..") }.should raise_exception(Rouge::Reader::UnexpectedCharacterError)
+    end
+  end
+
+  it "should read symbols" do
+    @ns.read("loki").should eq Rouge::Symbol[:loki]
+    @ns.read("wah?").should eq Rouge::Symbol[:wah?]
+    @ns.read("!ruby!").should eq Rouge::Symbol[:"!ruby!"]
+    @ns.read("nil").should eq Rouge::Symbol[:nil]
+    @ns.read("nil").should eq nil
+    @ns.read("true").should eq Rouge::Symbol[:true]
+    @ns.read("true").should eq true
+    @ns.read("false").should eq Rouge::Symbol[:false]
+    @ns.read("false").should eq false
+    @ns.read("&").should eq Rouge::Symbol[:&]
+    @ns.read("*").should eq Rouge::Symbol[:*]
+    @ns.read("-").should eq Rouge::Symbol[:-]
+    @ns.read("+").should eq Rouge::Symbol[:+]
+    @ns.read("/").should eq Rouge::Symbol[:/]
+    @ns.read("|").should eq Rouge::Symbol[:|]
+    @ns.read("$").should eq Rouge::Symbol[:"$"]
+    @ns.read(".").should eq Rouge::Symbol[:"."]
+    @ns.read(".[]").should eq Rouge::Symbol[:".[]"]
+    @ns.read("=").should eq Rouge::Symbol[:"="]
+    @ns.read("%").should eq Rouge::Symbol[:"%"]
+    @ns.read(">").should eq Rouge::Symbol[:">"]
+    @ns.read("<").should eq Rouge::Symbol[:"<"]
+    @ns.read("%50").should eq Rouge::Symbol[:"%50"]
+    @ns.read("xyz#").should eq Rouge::Symbol[:"xyz#"]
+  end
+
+  describe "keywords" do
+    it "should read plain keywords" do
+      @ns.read(":loki").should eq :loki
+      @ns.read(":/").should eq :/
+      @ns.read(":wah?").should eq :wah?
+      @ns.read(":nil").should eq :nil
+      @ns.read(":true").should eq :true
+      @ns.read(":false").should eq :false
+    end
+
+    it "should read string-symbols" do
+      @ns.read(":\"!ruby!\"").should eq :"!ruby!"
+    end
+  end
+
+  describe "strings" do
+    it "should read plain strings" do
+      @ns.read("\"akashi yo\"").should eq "akashi yo"
+      @ns.read("\"akashi \n woah!\"").should eq "akashi \n woah!"
+    end
+
+    it "should read escape sequences" do
+      @ns.read("\"here \\\" goes\"").should eq "here \" goes"
+      @ns.read("\"here \\\\ goes\"").should eq "here \\ goes"
+      @ns.read("\"\\a\\b\\e\\f\\n\\r\"").should eq "\a\b\e\f\n\r"
+      @ns.read("\"\\s\\t\\v\"").should eq "\s\t\v"
+    end
+
+    it "should read strings as frozen" do
+      @ns.read("\"bah\"").should be_frozen
+    end
+  end
+
+  describe "lists" do
+    it "should read the empty list" do
+      @ns.read("()").should eq Rouge::Seq::Cons[]
+    end
+
+    it "should read one-element lists" do
+      @ns.read("(tiffany)").should eq Rouge::Seq::Cons[Rouge::Symbol[:tiffany]]
+      @ns.read("(:raaaaash)").
+          should eq Rouge::Seq::Cons[:raaaaash]
+    end
+
+    it "should read multiple-element lists" do
+      @ns.read("(1 2 3)").should eq Rouge::Seq::Cons[1, 2, 3]
+      @ns.read("(true () [] \"no\")").
+          should eq Rouge::Seq::Cons[Rouge::Symbol[:true], Rouge::Seq::Cons[], [], "no"]
+    end
+
+    it "should read nested lists" do
+      @ns.read("(((3) (())) 9 ((8) (8)))").
+          should eq Rouge::Seq::Cons[Rouge::Seq::Cons[Rouge::Seq::Cons[3],
+          Rouge::Seq::Cons[Rouge::Seq::Cons[]]], 9,
+          Rouge::Seq::Cons[Rouge::Seq::Cons[8], Rouge::Seq::Cons[8]]]
+    end
+
+    it "should read lists as frozen" do
+      @ns.read("()").should be_frozen
+      @ns.read("(1)").should be_frozen
+      @ns.read("(1 2)").should be_frozen
+    end
+  end
+
+  describe "vectors" do
+    it "should read the empty vector" do
+      @ns.read("[]").should eq []
+    end
+
+    it "should read one-element vectors" do
+      @ns.read("[tiffany]").should eq [Rouge::Symbol[:tiffany]]
+      @ns.read("[:raaaaash]").should eq [:raaaaash]
+    end
+
+    it "should read multiple-element vectors" do
+      @ns.read("[1 2 3]").should eq [1, 2, 3]
+      @ns.read("[true () [] \"no\"]").
+          should eq [Rouge::Symbol[:true], Rouge::Seq::Cons[], [], "no"]
+    end
+
+    it "should read nested vectors" do
+      @ns.read("[[[3] [[]]] 9 [[8] [8]]]").
+          should eq [[[3], [[]]], 9, [[8], [8]]]
+    end
+
+    it "should read vectors as frozen" do
+      @ns.read("[]").should be_frozen
+      @ns.read("[1]").should be_frozen
+      @ns.read("[1 2]").should be_frozen
+    end
+  end
+
+  describe "quotations" do
+    it "should read 'X as (QUOTE X)" do
+      @ns.read("'x").
+          should eq Rouge::Seq::Cons[Rouge::Symbol[:quote], Rouge::Symbol[:x]]
+    end
+
+    it "should read ''('X) as (QUOTE (QUOTE ((QUOTE X))))" do
+      @ns.read("''('x)").
+          should eq Rouge::Seq::Cons[Rouge::Symbol[:quote],
+                    Rouge::Seq::Cons[Rouge::Symbol[:quote],
+                    Rouge::Seq::Cons[Rouge::Seq::Cons[Rouge::Symbol[:quote],
+                                            Rouge::Symbol[:x]]]]]
+    end
+  end
+
+  describe "vars" do
+    it "should read #'X as (VAR X)" do
+      @ns.read("#'x").
+          should eq Rouge::Seq::Cons[Rouge::Symbol[:var], Rouge::Symbol[:x]]
+    end
+
+    it "should read #'#'(#'X) as (VAR (VAR ((VAR X))))" do
+      @ns.read("#'#'(#'x)").
+          should eq Rouge::Seq::Cons[Rouge::Symbol[:var],
+                    Rouge::Seq::Cons[Rouge::Symbol[:var],
+                    Rouge::Seq::Cons[Rouge::Seq::Cons[Rouge::Symbol[:var],
+                                            Rouge::Symbol[:x]]]]]
+    end
+  end
+
+  describe "maps" do
+    it "should read the empty map" do
+      @ns.read("{}").should eq({})
+    end
+
+    it "should read one-element maps" do
+      @ns.read("{a 1}").to_s.should eq({Rouge::Symbol[:a] => 1}.to_s)
+      @ns.read("{\"quux\" [lambast]}").
+          should eq({"quux" => [Rouge::Symbol[:lambast]]})
+    end
+
+    it "should read multiple-element maps" do
+      @ns.read("{:a 1 :b 2}").should eq({:a => 1, :b => 2})
+      @ns.read("{:f :f, :y :y\n:z :z}").
+          should eq({:f => :f, :y => :y, :z => :z})
+    end
+
+    it "should read nested maps" do
+      @ns.read("{:a {:z 9} :b {:q q}}").should eq(
+        {:a => {:z => 9}, :b => {:q => Rouge::Symbol[:q]}})
+      @ns.read("{{9 7} 5}").should eq({{9 => 7} => 5})
+    end
+
+    it "should read maps as frozen" do
+      @ns.read("{}").should be_frozen
+      @ns.read("{:a 1}").should be_frozen
+    end
+  end
+
+  describe "whitespace behaviour" do
+    it "should not fail with trailing whitespace" do
+      lambda {
+        @ns.read(":hello    \n\n\t\t  ").should eq :hello
+      }.should_not raise_exception
+    end
+
+    it "should deal with whitespace in strange places" do
+      lambda {
+        @ns.read("[1 ]").should eq [1]
+        @ns.read(" [   2 ] ").should eq [2]
+      }.should_not raise_exception
+    end
+  end
+
+  describe "empty reads" do
+    it "should fail on empty reads" do
+      lambda {
+        @ns.read("")
+      }.should raise_exception(Rouge::Reader::EndOfDataError)
+
+      lambda {
+        @ns.read("    \n         ")
+      }.should raise_exception(Rouge::Reader::EndOfDataError)
+    end
+  end
+
+  describe "comments" do
+    it "should ignore comments" do
+      @ns.read("42 ;what!").should eq 42
+      @ns.read("[42 ;what!\n15]").should eq [42, 15]
+
+      lambda {
+        @ns.read(";what!")
+      }.should raise_exception(Rouge::Reader::EndOfDataError)
+
+      @ns.read(";what!\nhmm").should eq Rouge::Symbol[:hmm]
+    end
+  end
+
+  describe "syntax-quoting" do
+    describe "non-cons lists" do
+      it "should quote non-cons lists" do
+        @ns.read('`3').should eq @ns.read("'3")
+        @ns.read('`"my my my"').should eq @ns.read(%{'"my my my"})
+      end
+
+      it "should dequote within non-cons lists" do
+        @ns.read('`~3').should eq @ns.read("3")
+        @ns.read('``~3').should eq @ns.read("'3")
+        @ns.read('``~~3').should eq @ns.read("3")
+      end
+
+      it "should qualify symbols" do
+        @ns.read('`a').should eq @ns.read("'user.spec/a")
+      end
+
+      it "should not qualify special symbols" do
+        @ns.read('`.a').should eq @ns.read("'.a")
+        @ns.read('`&').should eq @ns.read("'&")
+        @ns.read('`|').should eq @ns.read("'|")
+      end
+    end
+
+    describe "cons-lists" do
+      it "should quote cons lists" do
+        @ns.read('`(1 2)').should eq @ns.read("(list '1 '2)")
+        @ns.read('`(a b)').
+            should eq @ns.read("(list 'user.spec/a 'user.spec/b)")
+      end
+
+      it "should dequote within cons lists" do
+        @ns.read('`(a ~b)').should eq @ns.read("(list 'user.spec/a b)")
+        @ns.read('`(a ~(b `(c ~d)))').
+            should eq @ns.read("(list 'user.spec/a (b (list 'user.spec/c d)))")
+        @ns.read('`(a `(b ~c))').
+            should eq @ns.read("(list 'user.spec/a (list 'user.spec/list " \
+                               "(list 'quote 'user.spec/b) 'user.spec/c))")
+        @ns.read('`~`(x)').should eq @ns.read("(list 'user.spec/x)")
+      end
+
+      it "should dequote within maps" do
+        @ns.read('`{a ~b}').to_s.should eq @ns.read("{'user.spec/a b}").to_s
+      end
+
+      it "should splice within seqs and vectors" do
+        @ns.read('`(a ~@b c)').
+            should eq @ns.read("(seq (concat (list 'user.spec/a) b " \
+                               "(list 'user.spec/c)))")
+        @ns.read('`(~@(a b) ~c)').
+            should eq @ns.read("(seq (concat (a b) (list c)))")
+        @ns.read('`[a ~@b c]').should eq @ns.read(<<-ROUGE)
+            (apply vector (concat (list 'user.spec/a) b (list 'user.spec/c)))
+        ROUGE
+        @ns.read('`[~@(a b) ~c]').
+            should eq @ns.read("(apply vector (concat (a b) (list c)))")
+      end
+    end
+
+    describe "gensyms" do
+      it "should read as unique in each invocation" do
+        a1 = @ns.read('`a#')
+        a2 = @ns.read('`a#')
+        a1.to_s.should_not eq a2.to_s
+      end
+
+      it "should read identically within each invocation" do
+        as = @ns.read('`(a# a# `(a# a#))')
+        as = as
+          .map {|e| e.respond_to?(:to_a) ? e.to_a : e}.to_a.flatten
+          .flat_map {|e| e.respond_to?(:to_a) ? e.to_a : e}
+          .flat_map {|e| e.respond_to?(:to_a) ? e.to_a : e}
+          .find_all {|e|
+            e.is_a?(Rouge::Symbol) and e.name.to_s =~ /^a/
+          }
+        as.length.should eq 4
+        as[0].should eq as[1]
+        as[2].should eq as[3]
+        as[0].should_not eq as[2]
+      end
+    end
+  end
+
+  describe "anonymous functions" do
+    it "should read anonymous functions" do
+      @ns.read('#(1)').should eq @ns.read('(fn [] (1))')
+      @ns.read('#(do 1)').should eq @ns.read('(fn [] (do 1))')
+      @ns.read('#(%)').should eq @ns.read('(fn [%1] (%1))')
+      @ns.read('#(%2)').should eq @ns.read('(fn [%1 %2] (%2))')
+      @ns.read('#(%5)').should eq @ns.read('(fn [%1 %2 %3 %4 %5] (%5))')
+      @ns.read('#(%2 %)').should eq @ns.read('(fn [%1 %2] (%2 %1))')
+    end
+  end
+
+  describe "metadata" do
+    it "should read metadata" do
+      y = @ns.read('^{:x 1} y')
+      y.should eq Rouge::Symbol[:y]
+      y.meta.to_s.should eq({:x => 1}.to_s)
+    end
+
+    it "should stack metadata" do
+      y = @ns.read('^{:y 2} ^{:y 3 :z 2} y')
+      y.should eq Rouge::Symbol[:y]
+      y.meta.should include({:y => 2, :z => 2})
+    end
+
+    it "should assign tags" do
+      y = @ns.read('^"xyz" y')
+      y.should eq Rouge::Symbol[:y]
+      y.meta.should include({:tag => "xyz"})
+    end
+
+    it "should assign symbol markers" do
+      y = @ns.read('^:blargh y')
+      y.should eq Rouge::Symbol[:y]
+      y.meta.should include({:blargh => true})
+    end
+  end
+
+  describe "deref" do
+    it "should read derefs" do
+      @ns.read('@(boo)').should eq @ns.read('(rouge.core/deref (boo))')
+    end
+  end
+
+  describe "multiple reading" do
+    it "should read multiple forms in turn" do
+      r = Rouge::Reader.new(@ns, "a b c")
+      r.lex.should eq Rouge::Symbol[:a]
+      r.lex.should eq Rouge::Symbol[:b]
+      r.lex.should eq Rouge::Symbol[:c]
+
+      lambda {
+        r.lex
+      }.should raise_exception(Rouge::Reader::EndOfDataError)
+    end
+  end
+
+  describe "the ns property" do
+    it "should return the ns the reader is in" do
+      Rouge::Reader.new(@ns, "").ns.should be @ns
+    end
+  end
+
+  describe "the comment dispatch" do
+    it "should be completely ignored" do
+      @ns.read('#_(xyz abc) :f').should eq :f
+    end
+  end
+
+  describe "regexp" do
+    it { @ns.read('#"abc"').should be_an_instance_of Regexp }
+  end
+end
+
+# vim: set sw=2 et cc=80: