rouge-lang 0.0.1

data/spec/rouge_spec.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+require 'term/ansicolor'
+
+describe Rouge do
+  before do
+    Rouge.boot!
+  end
+
+  describe "the rouge.core namespace" do
+    before do
+      @ns = Rouge[:"rouge.core"]
+    end
+
+    it "should contain the defn macro" do
+      lambda {
+        @ns[:defn].should be_an_instance_of Rouge::Macro
+      }.should_not raise_exception(Rouge::Context::BindingNotFoundError)
+    end
+  end
+
+  describe "the user namespace" do
+    before do
+      @ns = Rouge[:user]
+    end
+
+    it "should refer rouge.builtin, rouge.core and ruby" do
+      @ns.refers.should include(Rouge[:"rouge.builtin"])
+      @ns.refers.should include(Rouge[:"rouge.core"])
+      @ns.refers.should include(Rouge[:"ruby"])
+    end
+  end
+
+  describe "the Rouge specs" do
+    Dir[relative_to_spec("*.rg")].each do |file|
+      it "should pass #{File.basename file}" do
+        begin
+          r = Rouge::Context.new(Rouge[:user]).readeval(File.read(file))
+        rescue => e
+          STDOUT.puts Term::ANSIColor.red("#{e.class}: #{e.message}")
+          STDOUT.puts Term::ANSIColor.red(e.backtrace.join("\n"))
+          r = {:passed => 0, :failed => [["exception"]]}
+        end
+
+        total = r[:passed] + r[:failed].length
+
+        message = 
+            "#{total} example#{total == 1 ? "" : "s"}, " +
+            "#{r[:failed].length} failure#{r[:failed].length == 1 ? "" : "s"}"
+
+        if r[:failed].length > 0
+          STDOUT.puts Term::ANSIColor.red(message)
+          raise RuntimeError,
+              "#{r[:failed].length} failed " +
+              "case#{r[:failed].length == 1 ? "" : "s"} in #{file}:\n" +
+              r[:failed].map {|ex| "  - #{ex.join(" -> ")}"}.join("\n")
+        else
+          STDOUT.puts Term::ANSIColor.green(message)
+        end
+      end
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/spec/seq_spec.rb

@@ -0,0 +1,202 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::Seq::ASeq do
+  let(:seq) do
+    Class.new do
+      include Rouge::Seq::ASeq
+      def to_a; [:q]; end
+    end.new
+  end
+
+  describe "#seq" do
+    it "should return the original object" do
+     seq.seq.should be seq
+    end 
+  end
+
+  describe "the unimplemented methods" do
+    it { expect { seq.first
+                }.to raise_exception NotImplementedError }
+
+    it { expect { seq.next
+                }.to raise_exception NotImplementedError }
+  end
+
+  describe "#more" do
+    it "should return the value of next" do
+      r = double("next result")
+      seq.should_receive(:next).and_return(r)
+      seq.more.should be r
+    end
+
+    it "should return an empty list if next returns nil" do
+      r = double("next result")
+      seq.should_receive(:next).and_return(nil)
+      seq.more.should eq Rouge::Seq::Empty
+    end
+  end
+
+  describe "#cons" do
+    let(:head) { double("head") }
+
+    before { Rouge::Seq::Cons.should_receive(:new).with(head, seq) }
+    it { seq.cons(head) }
+  end
+
+  describe "#[]" do
+    let(:numbers) { Rouge::Seq::Cons[1, 2, 3] }
+
+    it { numbers[0].should eq 1 }
+    it { numbers[1].should eq 2 }
+
+    # XXX: unlike Clojure. Thoughts?
+    it { numbers[5].should eq nil }
+
+    it { numbers[-1].should eq 3 }
+    it { numbers[-2].should eq 2 }
+
+    # XXX: or generic seqs/lazyseqs/arrayseqs ...?
+    # to preserve Ruby interop probably straight Arrays.
+    # We won't be using this form from Rouge itself anyway.
+    it { numbers[0..-1].should eq [1, 2, 3] }
+    it { numbers[0..-2].should eq [1, 2] }
+    it { numbers[0...-2].should eq [1] }
+    it { numbers[2...-1].should eq [] }
+    it { numbers[2..-1].should eq [3] }
+  end
+
+  describe "#==" do
+    it { Rouge::Seq::Array.new([:q], 0).should eq seq }
+    it { Rouge::Seq::Array.new([:q, :r], 0).
+             should eq Rouge::Seq::Cons[:q, :r] }
+  end
+
+  describe "#each" do
+    it { Rouge::Seq::Cons[1].each.should be_an_instance_of Enumerator }
+  end
+end
+
+describe Rouge::Seq::Cons do
+  describe ".new" do
+    it { expect { Rouge::Seq::Cons.new(1, Rouge::Seq::Empty)
+                }.to_not raise_exception }
+
+    it { expect { Rouge::Seq::Cons.new(1, nil)
+                }.to_not raise_exception }
+
+    it { expect { Rouge::Seq::Cons.new(1, Rouge::Seq::Cons[:x])
+                }.to_not raise_exception }
+
+    it { expect { Rouge::Seq::Cons.new(1, Rouge::Seq::Array.new([], 0))
+                }.to_not raise_exception }
+
+    it { expect { Rouge::Seq::Cons.new(1, "blah")
+                }.to raise_exception(ArgumentError) }
+  end
+
+  describe ".[]" do
+    it { Rouge::Seq::Cons[].should eq Rouge::Seq::Empty }
+    it { Rouge::Seq::Cons[1].
+             should eq Rouge::Seq::Cons.new(1, Rouge::Seq::Empty) }
+    it { Rouge::Seq::Cons[1].should eq Rouge::Seq::Cons.new(1, nil) }
+    it { Rouge::Seq::Cons[1, 2].
+             should eq Rouge::Seq::Cons.new(
+                1, Rouge::Seq::Cons.new(2, Rouge::Seq::Empty)) }
+    it { Rouge::Seq::Cons[1, 2, 3].
+        should eq Rouge::Seq::Cons.new(1,
+                  Rouge::Seq::Cons.new(2,
+                  Rouge::Seq::Cons.new(3, Rouge::Seq::Empty))) }
+  end
+
+  describe "#inspect" do
+    it { Rouge::Seq::Cons[].inspect.should eq "()" }
+    it { Rouge::Seq::Cons[1].inspect.should eq "(1)" }
+    it { Rouge::Seq::Cons[1, 2].inspect.should eq "(1 2)" }
+    it { Rouge::Seq::Cons[1, 2, 3].inspect.should eq "(1 2 3)" }
+    it { Rouge::Seq::Cons[1, 2, 3].tail.inspect.should eq "(2 3)" }
+  end
+
+  describe "the ASeq implementation" do
+    subject { Rouge::Seq::Cons[1, 2, 3] }
+
+    describe "#first" do
+      its(:first) { should eq 1 }
+    end
+
+    describe "#next" do
+      its(:next) { should be_an_instance_of Rouge::Seq::Cons }
+      its(:next) { should eq Rouge::Seq::Cons[2, 3] }
+      it { subject.next.next.next.should eq nil }
+    end
+  end
+end
+
+describe Rouge::Seq::Array do
+  describe "#first" do
+    it { Rouge::Seq::Array.new([:a, :b, :c], 0).first.should eq :a }
+    it { Rouge::Seq::Array.new([:a, :b, :c], 1).first.should eq :b }
+    it { Rouge::Seq::Array.new([:a, :b, :c], 2).first.should eq :c }
+  end
+
+  describe "#next" do
+    subject { Rouge::Seq::Array.new([:a, :b, :c], 0).next }
+
+    it { should be_an_instance_of Rouge::Seq::Array }
+    it { should eq [:b, :c] }
+  end
+end
+
+describe Rouge::Seq::Lazy do
+  let(:sentinel) { double("sentinel") }
+  let(:trigger) { Rouge::Seq::Lazy.new(lambda { sentinel.call }) }
+  let(:non_seq) { Rouge::Seq::Lazy.new(lambda { 7 }) }
+  let(:error) { Rouge::Seq::Lazy.new(lambda { raise "boom" }) }
+
+  describe "not evalled until necessary" do
+    context "not realised" do
+      before { sentinel.should_not_receive(:call) }
+      it { trigger }
+    end
+
+    context "realised" do
+      before { sentinel.should_receive(:call).and_return [1, 2] }
+
+      it { trigger.seq.should eq [1, 2] }
+      it { trigger.first.should eq 1 }
+      it { trigger.next.should eq [2] }
+    end
+  end
+
+  describe "not multiply evalled on non-seq" do
+    it do
+      # Weird, but most similar to Clojure (by experiment).
+      expect { non_seq.seq }.to raise_exception
+      expect { non_seq.seq.should be Rouge::Seq::Empty
+             }.to_not raise_exception
+    end
+  end
+
+  describe "multiply evalled on error" do
+    it do
+      expect { error.seq }.to raise_exception
+      expect { error.seq }.to raise_exception
+    end
+  end
+end
+
+describe Rouge::Seq do
+  describe ".seq" do
+    context Array do
+      subject { Rouge::Seq.seq([:a]) }
+      it { should be_an_instance_of Rouge::Seq::Array }
+      it { should eq Rouge::Seq::Array.new([:a], 0) }
+
+      let(:arrayseq) { Rouge::Seq::Array.new([:a], 0) }
+      it { Rouge::Seq.seq(arrayseq).should be arrayseq }
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rspec/autorun'
+
+RSpec.configure do |config|
+  config.order = 'random'
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+def relative_to_spec name
+  File.join(File.dirname(File.absolute_path(__FILE__)), name)
+end
+
+# vim: set sw=2 et cc=80:

data/spec/symbol_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::Symbol do
+  describe "lookup" do
+    it { Rouge::Symbol[:true].should be true }
+    it { Rouge::Symbol[:false].should be false }
+    it { Rouge::Symbol[:nil].should be nil }
+  end
+
+  describe ".[]" do
+    it { Rouge::Symbol[:a].should_not be Rouge::Symbol[:a] }
+    # but:
+    it { Rouge::Symbol[:a].should eq Rouge::Symbol[:a] }
+  end
+
+  describe "#ns, #name" do
+    it { Rouge::Symbol[:abc].ns.should be_nil }
+    it { Rouge::Symbol[:abc].name.should eq :abc }
+    it { Rouge::Symbol[:"abc/def"].ns.should eq :abc }
+    it { Rouge::Symbol[:"abc/def"].name.should eq :def }
+    it { Rouge::Symbol[:/].ns.should be_nil }
+    it { Rouge::Symbol[:/].name.should eq :/ }
+    it { Rouge::Symbol[:"rouge.core//"].ns.should eq :"rouge.core" }
+    it { Rouge::Symbol[:"rouge.core//"].name.should eq :/ }
+  end
+
+  describe "#to_sym" do
+    it { Rouge::Symbol[:boo].to_sym.should eq :boo }
+    it { Rouge::Symbol[:"what/nice"].to_sym.should eq :"what/nice" }
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/spec/var_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe Rouge::Var do
+  describe "the constructor" do
+    it "creates an unbound var by default" do
+      v = Rouge::Var.new(:mop, :boo)
+      v.ns.should eq :mop
+      v.name.should eq :boo
+      v.deref.should be_an_instance_of Rouge::Var::Unbound
+    end
+
+    it "creates a bound var if requested" do
+      v = Rouge::Var.new(:quux, :huh, 99)
+      v.ns.should eq :quux
+      v.name.should eq :huh
+      v.deref.should eq 99
+    end
+  end
+
+  describe "equality" do
+    it "considers two vars equal if their nses and names are equal" do
+      Rouge::Var.new(:a, :a, :v).should == Rouge::Var.new(:a, :a, :v)
+      Rouge::Var.new(:a, :a, :w).should == Rouge::Var.new(:a, :a, :w)
+      Rouge::Var.new(:b, :a, :v).should_not == Rouge::Var.new(:a, :b, :v)
+      Rouge::Var.new(:b, :a, :v).should_not == Rouge::Var.new(:a, :a, :v)
+    end
+  end
+
+  describe "the stack" do
+    it "should override a var's root" do
+      v = Rouge::Var.new(:moop, :hello, :frank)
+      v.deref.should eq :frank
+
+      Rouge::Var.push({:hello => :joe})
+      v.deref.should eq :joe
+
+      Rouge::Var.push({:hello => :mark})
+      v.deref.should eq :mark
+
+      Rouge::Var.pop
+      v.deref.should eq :joe
+
+      Rouge::Var.pop
+      v.deref.should eq :frank
+    end
+  end
+end
+
+describe Rouge::Var::Unbound do
+  describe "the constructor" do
+    it "creates an unbound var's value" do
+      v = Rouge::Var.new(:raisin, :boo)
+      ub = Rouge::Var::Unbound.new(v)
+      ub.var.should be v
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

data/spec/wrappers_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'rouge'
+
+describe [
+    Rouge::Macro,
+    Rouge::Builtin,
+    Rouge::Dequote,
+    Rouge::Splice] do
+  describe "the constructor" do
+    it "should return a new wrapper" do
+      described_class.each do |klass|
+        klass.new(:abc).should be_an_instance_of klass
+      end
+    end
+
+    it "should function with the alternate form" do
+      described_class.each do |klass|
+        klass[:aoeu].should eq klass.new(:aoeu)
+      end
+    end
+  end
+
+  describe "equality" do
+    it "should be true for two wrappers with the same underlying object" do
+      described_class.each do |klass|
+        klass.new(:xyz).should eq klass.new(:xyz)
+      end
+    end
+  end
+
+  describe "the inner getter" do
+    it "should return the object passed in" do
+      described_class.each do |klass|
+        klass.new(:boohoo).inner.should eq :boohoo
+        l = lambda {}
+        klass.new(l).inner.should eq l
+      end
+    end
+  end
+
+  describe "the Puby pretty-printing" do
+    it "should resemble the [] constructor" do
+      described_class.each do |klass|
+        klass[:hello].inspect.should eq "#{klass.name}[:hello]"
+      end
+    end
+  end
+end
+
+# vim: set sw=2 et cc=80:

metadata

@@ -0,0 +1,216 @@
+--- !ruby/object:Gem::Specification
+name: rouge-lang
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Arlen Christian Mart Cuss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: autotest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: autotest-growl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: autotest-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ZenTest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby + Clojure = Rouge.
+email:
+- ar@len.me
+executables:
+- rouge
+extensions: []
+extra_rdoc_files: []
+files:
+- .autotest
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/rouge
+- lib/boot.rg
+- lib/rouge.rb
+- lib/rouge/atom.rb
+- lib/rouge/builtins.rb
+- lib/rouge/compiler.rb
+- lib/rouge/context.rb
+- lib/rouge/metadata.rb
+- lib/rouge/namespace.rb
+- lib/rouge/printer.rb
+- lib/rouge/reader.rb
+- lib/rouge/repl.rb
+- lib/rouge/seq.rb
+- lib/rouge/symbol.rb
+- lib/rouge/var.rb
+- lib/rouge/version.rb
+- lib/rouge/wrappers.rb
+- misc/TODO
+- misc/vimrc
+- rouge-lang.gemspec
+- spec/atom_spec.rb
+- spec/builtins_spec.rb
+- spec/compiler_spec.rb
+- spec/context_spec.rb
+- spec/core_spec.rg
+- spec/metadata_spec.rb
+- spec/namespace_spec.rb
+- spec/printer_spec.rb
+- spec/reader_spec.rb
+- spec/rouge_spec.rb
+- spec/seq_spec.rb
+- spec/spec_helper.rb
+- spec/symbol_spec.rb
+- spec/var_spec.rb
+- spec/wrappers_spec.rb
+homepage: http://rouge.io/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: An implementation of Clojure for Ruby.
+test_files:
+- spec/atom_spec.rb
+- spec/builtins_spec.rb
+- spec/compiler_spec.rb
+- spec/context_spec.rb
+- spec/core_spec.rg
+- spec/metadata_spec.rb
+- spec/namespace_spec.rb
+- spec/printer_spec.rb
+- spec/reader_spec.rb
+- spec/rouge_spec.rb
+- spec/seq_spec.rb
+- spec/spec_helper.rb
+- spec/symbol_spec.rb
+- spec/var_spec.rb
+- spec/wrappers_spec.rb