rouge-lang 0.0.1

data/spec/compiler_spec.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::Compiler do
+  before do
+    @ns = Rouge[:"user.spec"].clear
+    @ns.refer Rouge[:"rouge.builtin"]
+
+    @read = lambda do |input|
+      Rouge::Reader.new(@ns, input).lex
+    end
+
+    @compile = lambda do |input|
+      form = @read.call(input)
+      Rouge::Compiler.compile(@ns, Set.new, form)
+    end
+  end
+
+  describe "lexical lookup" do
+    it "should compile with respect to locals" do
+      lambda {
+        @compile.call("(fn [] a)")
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+
+      lambda {
+        @compile.call("q")
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+
+      lambda {
+        @compile.call("(let [x 8] x)").
+            should eq @read.call("(let [x 8] x)")
+      }.should_not raise_exception
+
+      lambda {
+        @compile.call("(let [x 8] y)")
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+
+      lambda {
+        @compile.call("(let [x 8] ((fn [& b] (b)) | [e] e))")
+      }.should_not raise_exception
+
+      lambda {
+        @compile.call("(let [x 8] ((fn [& b] (b)) | [e] f))")
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+    end
+  end
+
+  describe "macro behaviour" do
+    it "should execute macro calls when compiling" do
+      @ns.set_here :thingy, Rouge::Macro[lambda {|f|
+        Rouge::Seq::Cons[Rouge::Symbol[:list], *f.to_a]
+      }]
+      @compile.call("(let [list 'thing] (thingy (1 2 3)))").
+          should eq @read.call("(let [list 'thing] (list 1 2 3))")
+    end
+  end
+
+  describe "symbol lookup" do
+    it "should compile X. symbols to procs which call X.new" do
+      x = double("<class>")
+      x.stub(:new => nil)
+
+      @ns.set_here :x, x
+      x_new = @compile.call("x.")
+      x_new.should be_an_instance_of Rouge::Compiler::Resolved
+
+      x.should_receive(:new).with(1, :z)
+      x_new.res.call(1, :z)
+    end
+
+    it "should find the var in our namespace for an unqualified symbol" do
+      @ns.set_here :tiffany, "wha?"
+      @compile.call("tiffany").res.
+          should eq Rouge::Var.new(:"user.spec", :tiffany, "wha?")
+    end
+
+    it "should find the var in a referred ns for an unqualified symbol" do
+      v = @compile.call("def").res
+      v.should be_an_instance_of(Rouge::Var)
+      v.ns.should eq :"rouge.builtin"
+      v.name.should eq :def
+      v.deref.should be_an_instance_of(Rouge::Builtin)
+    end
+
+    it "should find the var in any namespace for a qualified symbol" do
+      v = @compile.call("ruby/Kernel").res
+      v.should be_an_instance_of(Rouge::Var)
+      v.ns.should eq :ruby
+      v.name.should eq :Kernel
+      v.deref.should eq Kernel
+    end
+
+    it "should find the method for a new class instantiation" do
+      m = @compile.call("ruby/String.").res
+      m.should be_an_instance_of Method
+      m.receiver.should eq String
+      m.name.should eq :new
+    end
+  end
+
+  describe "sub-compilation behaviour" do
+    it "should compile Arrays and Hashes" do
+      lambda {
+        @compile.call("[a]")
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+
+      @ns.set_here :a, :a
+      lambda {
+        @compile.call("[a]")
+      }.should_not raise_exception
+
+      lambda {
+        @compile.call("{b c}")
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+
+      @ns.set_here :b, :b
+      lambda {
+        @compile.call("{b c}")
+      }.should raise_exception(Rouge::Namespace::VarNotFoundError)
+
+      @ns.set_here :c, :c
+      lambda {
+        @compile.call("{b c}")
+      }.should_not raise_exception
+    end
+
+    it "should compile inline blocks to fns" do
+      @compile.call("(let [a 'thing] (a | [b] b))").
+          should eq @read.call("(let [a 'thing] (a | (fn [b] b)))")
+    end
+
+    it { @compile.call("()").should eq Rouge::Seq::Empty }
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/spec/context_spec.rb

@@ -0,0 +1,293 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::Context do
+  before do
+    @a = Rouge::Context.new nil
+    @ab = Rouge::Context.new @a
+    @abb = Rouge::Context.new @ab
+    @ac = Rouge::Context.new @a
+    @a.set_here :root, 42
+    @a.set_here :bah, (@bah = Object.new)
+    @ab.set_here :root, 80
+    @ac.set_here :non, 50
+
+    @spec = Rouge::Namespace[:"user.spec"].clear
+    @spec.refer Rouge::Namespace[:"rouge.builtin"]
+    @spec.set_here :tiffany, "wha?"
+    @in_spec = Rouge::Context.new @spec
+    @in_spec.set_here :blah, "code code"
+
+    @ns = Rouge[:"rouge.builtin"]
+    @context = Rouge::Context.new @ns
+    @nested_context = Rouge::Context.new @context
+  end
+
+  describe "the [] method" do
+    it "should get the closest binding" do
+      @a[:root].should eq 42
+      @ab[:root].should eq 80
+      @abb[:root].should eq 80
+      @ac[:root].should eq 42
+      # var, because it's from a namespace
+      @context[:let].deref.should be_an_instance_of Rouge::Builtin
+    end
+
+    it "should raise an exception if a binding is not found" do
+      lambda {
+        @a[:non]
+      }.should raise_exception(Rouge::Context::BindingNotFoundError)
+    end
+  end
+
+  describe "the ns method" do
+    it "should get the namespace of a context that has one" do
+      @context.ns.should eq Rouge::Namespace[:"rouge.builtin"]
+    end
+
+    it "should get the namespace of a nested context that has one" do
+      @nested_context.ns.should eq Rouge::Namespace[:"rouge.builtin"]
+    end
+
+    it "should return nil if a context has none" do
+      @a.ns.should eq nil
+      @ab.ns.should eq nil
+    end
+  end
+
+  describe "the set_here method" do
+    it "should set in the given context, shadowing outer bindings" do
+      @ac.set_here :root, 90
+      @ac[:root].should eq 90
+      @a[:root].should eq 42
+    end
+  end
+
+  describe "the set_lexical method" do
+    it "should set in the closest context" do
+      @abb.set_lexical :root, 777
+      @abb[:root].should eq 777
+      @ab[:root].should eq 777
+      @a[:root].should eq 42
+    end
+
+    it "should raise an exception if a closest binding is not found" do
+      lambda {
+        @abb.set_lexical :non, 10
+      }.should raise_exception(Rouge::Context::BindingNotFoundError)
+    end
+  end
+
+  describe "the eval method" do
+    it "should eval a form in this context without processing the backtrace" do
+      @a.eval([5]).should eq [5]
+
+      begin
+        @a.eval(Rouge::Seq::Cons[Rouge::Symbol[:blorgh]])
+        raise "failed!"
+      rescue Rouge::Context::BindingNotFoundError => e
+        e.backtrace.any? {|line| line =~ /^\(rouge\):/}.should be_false
+      end
+    end
+  end
+
+  describe "the readeval method" do
+    it "should post-process the backtrace", :pending do
+      Rouge.boot!
+      context = Rouge::Context.new Rouge[:user]
+
+      ex = nil
+      begin
+        context.readeval(<<-ROUGE)
+          (do
+            (defn z [] (throw (RuntimeError. "boo")))
+            (defn y [] (z))
+            (defn x [] (y))
+            (x))
+        ROUGE
+      rescue RuntimeError => e
+        ex = e
+      end
+
+      ex.should_not be_nil
+      ex.backtrace[0..3].
+          should eq ["(rouge):?:rouge.builtin/throw",
+                     "(rouge):?:user/z",
+                     "(rouge):?:user/y",
+                     "(rouge):?:user/x"]
+    end
+
+    it "should compile with lexicals from the found context" do
+      context = Rouge::Context.new nil
+      context.set_here :quux, 4
+      context.set_here :bar, 5
+
+      Rouge::Compiler.should_receive(:compile).
+          with(context.ns, kind_of(Set), true) do |ns, lexicals, f|
+        lexicals.should eq Set[:quux, :bar]
+      end
+
+      context.readeval("true")
+    end
+  end
+
+  describe "the locate method" do
+    it "should find the method for a new call to a lexical" do
+      arg = double("<arg>")
+      m = @a.locate(Rouge::Symbol[:"bah."])
+      m.should be_an_instance_of Proc
+      @bah.should_receive(:new).with(arg)
+      m.call(arg)
+    end
+  end
+
+  it "should evaluate quotations to their unquoted form" do
+    @context.readeval("'x").should eq @ns.read("x")
+    @context.readeval("'':zzy").should eq @ns.read("':zzy")
+  end
+
+  describe "symbols" do
+    it "should evaluate symbols to the object within their context" do
+      @context.set_here :vitamin_b, "vegemite"
+      @context.readeval("vitamin_b").should eq "vegemite"
+
+      subcontext = Rouge::Context.new @context
+      subcontext.set_here :joy, [:yes]
+      subcontext.set_here :/, "wah"
+      subcontext.readeval("joy").should eq [:yes]
+      subcontext.readeval("vitamin_b").should eq "vegemite"
+      subcontext.readeval("/").should eq "wah"
+    end
+
+    it "should evaluate symbols in other namespaces" do
+      @context.readeval("ruby/Object").should eq Object
+      @context.readeval("ruby/Exception").should eq Exception
+    end
+
+    it "should evaluate nested objects" do
+      @context.readeval("ruby/Rouge.Context").should eq Rouge::Context
+      @context.readeval("ruby/Errno.EAGAIN").should eq Errno::EAGAIN
+    end
+  end
+
+  it "should evaluate other things to themselves" do
+    @context.eval(4).should eq 4
+    @context.eval("bleep bloop").should eq "bleep bloop"
+    @context.eval(:"nom it").should eq :"nom it"
+    @context.readeval("{:a :b, 1 2}").to_s.should eq({:a => :b, 1 => 2}.to_s)
+
+    l = lambda {}
+    @context.eval(l).should eq l
+
+    o = Object.new
+    @context.eval(o).should eq o
+  end
+
+  it "should evaluate hash and vector arguments" do
+    @context.readeval("{\"z\" 92, 'x ''5}").to_s.
+        should eq @ns.read("{\"z\" 92, x '5}").to_s
+
+    subcontext = Rouge::Context.new @context
+    subcontext.set_here :lolwut, "off"
+    subcontext.readeval("{lolwut [lolwut]}").
+        should eq @ns.read('{"off" ["off"]}')
+  end
+
+  describe "function calls" do
+    it "should evaluate function calls" do
+      subcontext = Rouge::Context.new @context
+      subcontext.set_here :f, lambda {|x| "hello #{x}"}
+      subcontext.readeval('(f "world")').should eq "hello world"
+    end
+
+    it "should evaluate macro calls" do
+      macro = Rouge::Macro[lambda {|n, *body|
+        Rouge::Seq::Cons[Rouge::Symbol[:let], Rouge::Seq::Cons[n, "example"].freeze,
+          *body]
+      }]
+
+      @ns.set_here :macro, macro
+
+      subcontext = Rouge::Context.new @context
+      subcontext.set_here :f, lambda {|x,y| x + y}
+      subcontext.readeval('(macro bar (f bar bar))').should eq "exampleexample"
+    end
+
+    it "should evaluate calls with inline blocks and block binds" do
+      @context.readeval('((fn [a | b] (b a)) 42 | [e] (./ e 2))').should eq 21
+    end
+
+    describe "Ruby interop" do
+      describe "new object creation" do
+        it "should call X.new with (X.)" do
+          klass = double("klass")
+          klass.should_receive(:new).with(@ns.read('a')).and_return(:b)
+
+          subcontext = Rouge::Context.new @context
+          subcontext.set_here :klass, klass
+          subcontext.readeval("(klass. 'a)").should eq :b
+        end
+      end
+
+      describe "generic method calls" do
+        it "should call x.y(:z) with (.y x 'z)" do
+          x = double("x")
+          x.should_receive(:y).with(@ns.read('z')).and_return(:tada)
+
+          subcontext = Rouge::Context.new @context
+          subcontext.set_here :x, x
+          subcontext.readeval("(.y x 'z)").should eq :tada
+        end
+
+        it "should call q.r(:s, &t) with (.r q 's | t)" do
+          q = double("q")
+          t = lambda {}
+          q.should_receive(:r).with(@ns.read('s'), &t).and_return(:bop)
+
+          subcontext = Rouge::Context.new @context
+          subcontext.set_here :q, q
+          subcontext.set_here :t, t
+          subcontext.readeval("(.r q 's | t)").should eq :bop
+        end
+
+        it "should call a.b(:c) {|d| d + 1} with (.b a 'c | [d] (.+ d 1))" do
+          a = double("a")
+          a.should_receive(:b) do |c, &b|
+            c.should eq @ns.read('c')
+            b.call(1).should eq 2
+            b.call(2).should eq 3
+            b.call(3).should eq 4
+            :ok
+          end
+
+          subcontext = Rouge::Context.new @context
+          subcontext.set_here :a, a
+          subcontext.readeval("(.b a 'c | [d] (.+ d 1))").should eq :ok
+        end
+      end
+    end
+
+    describe "keywords in call position" do
+      it { @context.readeval('(:nope {:yep true})').should be_nil }
+      it { @context.readeval('(:test "fail")').should be_nil }
+      it { @context.readeval('(:pale {:pale "ale"})').should eq "ale" }
+      it { @context.readeval('(:red {:white "moscato"} "merlot")').
+             should eq "merlot" }
+
+      it { expect { @context.readeval('(:will "raise" "an" "error")')
+                  }.to raise_error(ArgumentError) }
+    end
+
+    describe "hashes in call position" do
+      it { @context.readeval('({:wham "bam"} :boom)').should be_nil }
+      it { @context.readeval('({:slam "dunk"} :slam)').should eq "dunk" }
+      it { @context.readeval('({:immortal false} :mortal true)').
+             should be_true }
+      it { expect { @context.readeval('({:this "will"} :raise "an" "error")')
+                  }.to raise_error(ArgumentError) }
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/spec/core_spec.rg

@@ -0,0 +1,123 @@
+;; -*- mode: clojure; -*-
+
+(ns ^{:doc "Spec tests for the Rouge core."
+      :author "Arlen Christian Mart Cuss"}
+  spec.rouge.core
+  (:use rouge.test))
+
+(testing "list"
+  (testing "empty list creation"
+    (is (= (list) '())))
+  (testing "unary list creation"
+    (is (= (list "trent") '("trent")))
+    (is (= (list true) '(true))))
+  (testing "n-ary list creation"
+    (is (= (apply list (range 1 6)) (.to_a (ruby/Range. 1 5))))))
+
+(testing "or"
+  (is (let [q (atom 0)]
+        (or 1 (swap! q inc))
+        (= @q 0))))
+
+(testing "and"
+  (is (let [q (atom 0)]
+        (and nil (swap! q inc))
+        (= @q 0))))
+
+(testing "sequential"
+  (is (sequential? []))
+  (is (sequential? [1]))
+  (is (sequential? ()))
+  (is (sequential? '(1)))
+  (is (not (sequential? nil))))
+
+(testing "="
+  (is (.== false (= () nil))))
+
+(testing "seq"
+  (is (.nil? (seq ())))
+  (is (.nil? (seq nil)))
+  (is (.nil? (seq []))))
+
+(testing "first"
+  (is (.nil? (first nil)))
+  (is (.nil? (first ()))))
+
+(testing "rest"
+  (is (.== (rest nil) ()))
+  (is (.== (rest ()) ())))
+
+(testing "next"
+  (is (.nil? (next nil)))
+  (is (.nil? (next ()))))
+
+(testing "nth"
+  (is (= 1 (nth [1 2 3] 0)))
+  (is (= 2 (nth [1 2 3] 1)))
+  (is (= 3 (nth [1 2 3] 2))))
+
+(defmacro sample-1 [f] `(do ~f))
+(defmacro sample-2 [f] `(do ~@f ~@f))
+
+(testing "macroexpand"
+  (is (= '(do x) (macroexpand '(sample-1 x))))
+  (is (= '(do x y x y) (macroexpand '(sample-2 (x y))))))
+
+#_(testing "var passing"
+  (is (= #'my-var (do
+                    (def my-var 4)
+                    (let [take-var (fn [v] v)]
+                      (take-var #'my-var))))))
+
+#_(testing "for")
+
+(testing "the -> macro"
+  (is (= 3 (macroexpand '(-> 3))))
+  (is (= '(:x 3) (macroexpand '(-> 3 :x))))
+  (is (= '(:y 3 2) (macroexpand '(-> 3 (:y 2)))))
+  (is (= '(:z (:y 3 2)) (macroexpand '(-> 3 (:y 2) :z))))
+  (is (= '(:z (:y 3 2) 8 9) (macroexpand '(-> 3 (:y 2) (:z 8 9)))))
+
+  (pending
+    ; this fails -- it compiles the inc ref.
+    (is (= '(inc 3) (macroexpand '(-> 3 inc))))
+    ; this fails too -- something weird.
+    (is (= '('inc 3) (macroexpand '(-> 3 'inc))))))
+
+(testing "map"
+  (is (= Rouge.Seq.Lazy (class (map inc [1 2 3]))))
+  (is (= '(2 3 4) (map inc [1 2 3])))
+  (is (= 1
+         (let [q (atom 0)
+               lazy (map #(do (swap! q inc) (inc %)) [1 2 3])]
+           (first lazy)
+           @q)))
+  (is (= 1
+         (let [q (atom 0)
+               lazy (map #(do (swap! q inc) (inc %)) [1 2 3])]
+           (first lazy)
+           (first lazy)
+           @q)))
+  (is (= 2
+         (let [q (atom 0)
+               lazy (map #(do (swap! q inc) (inc %)) [1 2 3])]
+           (first (next lazy))
+           @q)))
+  (is (= 3
+         (let [q (atom 0)
+               lazy (map #(do (swap! q inc) (inc %)) [1 2 3])]
+           (first (next (next lazy)))
+           @q)))
+  (is (= 3
+         (let [q (atom 0)
+               lazy (map #(do (swap! q inc) (inc %)) [1 2 3])]
+           (first (next (next (next lazy))))
+           @q)))
+
+  (testing "in destructuring"
+      (is (= 2
+             (let [q (atom 0)
+                   [hd & tl] (map #(do (swap! q inc) (inc %)) [1 2 3])]
+               @q)))))
+
+; vim: set ft=clojure: