rouge-lang 0.0.6 → 0.0.7

data/bin/rouge

@@ -11,6 +11,7 @@ option_parser = OptionParser.new do |opts|
 
   opts.on('-v', '--version', 'Print version number') do
     puts "Rouge #{Rouge::VERSION}"
+    exit 0
   end
 
   opts.on('-e STR', '--eval STR', 'Evaluate the contents of STR') do |str|

data/lib/rouge.rb

@@ -18,6 +18,7 @@ module Rouge
   require 'rouge/printer'
   require 'rouge/context'
   require 'rouge/repl'
+  require 'set'
 
   def self.print(form, out)
     Rouge::Printer.print form, out

data/lib/rouge/compiler.rb

@@ -24,6 +24,19 @@ module Rouge::Compiler
         # TODO: cache found ns/var/context or no. of context parents.
         form
       else
+        if form.ns and !Rouge::Namespace.get(form.ns)
+          # ns specified but no actual namespace so-called.
+          if form.ns["/"]
+            # ns/Const/method ?
+            method = form.name
+            form = Rouge::Symbol[form.ns]
+          else
+            # Const/method ?
+            method = form.name
+            form = Rouge::Symbol[form.ns]
+          end
+        end
+
         resolved = form.ns ? Rouge[form.ns] : ns
 
         lookups = form.name_parts
@@ -42,6 +55,12 @@ module Rouge::Compiler
           resolved = klass.method(:new)
         end
 
+        if method
+          receiver = resolved
+          receiver = receiver.deref if receiver.is_a?(Rouge::Var)
+          resolved = receiver.method(method)
+        end
+
         Resolved.new resolved
       end
     when Array

data/lib/rouge/context.rb

@@ -210,6 +210,18 @@ class Rouge::Context
         raise ArgumentError,
           "Wrong number of args (#{num_args}) passed to ruby/Hash"
       end
+    when Set
+      if num_args == 1
+        el = args[0]
+        if fun.include? el
+          el
+        else
+          nil
+        end
+      else
+        raise ArgumentError,
+          "Wrong number of args (#{num_args}) passed to ruby/Set"
+      end
     else
       fun.call(*args, &block)
     end

data/lib/rouge/namespace.rb

@@ -28,6 +28,7 @@ class Rouge::Namespace
     end
 
     @refers << ns if not @refers.include? ns
+    self
   end
 
   def [](key)
@@ -79,6 +80,10 @@ class << Rouge::Namespace
     @namespaces[ns] = new(ns)
   end
 
+  def get(ns)
+    @namespaces[ns]
+  end
+
   def []=(ns, value)
     @namespaces[ns] = value
   end

data/lib/rouge/printer.rb

@@ -53,6 +53,13 @@ module Rouge::Printer
         print(kv[1], out)
       end
       out << "}"
+    when Set
+      out << "\#{"
+      form.each_with_index do |el, i|
+        print el, out
+        out << " " unless i == (form.size - 1)
+      end
+      out << "}"
     when NilClass
       out << "nil"
     when TrueClass

data/lib/rouge/reader.rb

@@ -16,7 +16,6 @@ class Rouge::Reader
     @gensyms = []
   end
 
-
   def lex
     r =
       case peek
@@ -247,32 +246,47 @@ class Rouge::Reader
   end
 
   def regexp
-    s = ""
-    t = '"'
+    expression = ""
+    terminator = '"'
+
     while true
-      c = @src[@n]
+      char = @src[@n]
 
-      if c.nil?
-        reader_raise EndOfDataError, "in regexp, got: #{s}"
+      if char.nil?
+        reader_raise EndOfDataError, "in regexp, got: #{expression}"
       end
 
       @n += 1
 
-      if c == t
+      if char == terminator
         break
       end
 
-      if c == ?\\
-        c = "\\"
-        if peek == ?"
-          c << consume
+      if char == ?\\
+        char = "\\"
+
+        # Prevent breaking early.
+        if peek == terminator
+          char << consume
         end
       end
 
-      s << c
+      expression << char
     end
 
-    Regexp.new(s).freeze
+    Regexp.new(expression).freeze
+  end
+
+  def set
+    s = Set.new
+
+    until peek == '}'
+      el = lex
+      s.add el
+    end
+
+    consume
+    s.freeze
   end
 
   def dispatch
@@ -284,6 +298,9 @@ class Rouge::Reader
           Rouge::Symbol[:fn],
           (1..count).map {|n| Rouge::Symbol[:"%#{n}"]}.freeze,
           body]
+    when "{"
+      consume
+      set
     when "'"
       consume
       Rouge::Seq::Cons[Rouge::Symbol[:var], lex]

data/lib/rouge/seq.rb

@@ -264,6 +264,10 @@ module Rouge::Seq
       seq(form.to_a)
     when String
       seq(form.chars)
+    when Set
+      seq(form.to_a)
+    when Hash
+      seq(form.to_a)
     else
       raise UnknownSeqError, form.inspect
     end

data/lib/rouge/version.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 module Rouge
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end
 
 # vim: set sw=2 et cc=80:

data/misc/TODO

@@ -1,8 +1,4 @@
 NEXT:
-- (count "xyz") => 3, (map … "xyz") etc.
-- (ruby/)Time/now ==> Time.now
-- continue decruft Context, shift tests to Compiler as appropriate; revise most
-  specs.
 - extend DESTRUCTURE from LET to FN, etc.
 - refactor DEFN, DEFMACRO, LET, BINDING(?) to make use of above
 - may be faster for general wrapper classes to use Struct?
@@ -11,7 +7,6 @@ miscellaeny
 -----------
 - MACROEXPAND
 - SPEED test. run core specs a few times and time.
-- everything in ::Rouge should be accessible via rouge.builtin
 - organise boot.rg
 - test the whole core
 - omit Ruby from tracebacks?
@@ -21,20 +16,22 @@ miscellaeny
 ruby interop
 ------------
 - accessing the scope/self (DSLs!)
-- proc or lambda? setting ARITY.
+- proc or lambda? setting ARITY. May need to emulate with generated code.
 - DEFN/DEFMACRO/etc. should create strict lambdas, but FN/#() should not.
     Emulate by accepting |*a| and selecting ourselves how strict we want to be.
 
 "hard" tasks
 ------------
 - have a core "apply" function which can be used by eval, defmacro, etc.
+- continue decruft Context, shift tests to Compiler as appropriate; revise most
+  specs.
 
 core lang
 ---------
 - NON-dynamic/special vars
 - INTERN
 - FOR
-- multi-form defn: (defn x ([a] ...) ([a b] ...))
+- multi-form defn: (defn x ([a] ...) ([a b] ...)) (generalise defmacro's)
 - atoms (actually multithreaded), refs, agents
 - rest of the clojure core API (maybe even in clojure.core ns)
 - clojure-ish IO libraries which expose async IO

data/spec/compiler_spec.rb

@@ -3,134 +3,139 @@ require 'spec_helper'
 require 'rouge'
 
 describe Rouge::Compiler do
-  before do
-    @ns = Rouge[:"user.spec"].clear
-    @ns.refer Rouge[:"rouge.builtin"]
+  let(:ns) { Rouge[:"user.spec"].clear.refer(Rouge[:"rouge.builtin"]) }
 
-    @read = lambda do |input|
-      Rouge::Reader.new(@ns, input).lex
-    end
+  let(:read) { lambda {|input|
+    Rouge::Reader.new(ns, input).lex
+  } }
 
-    @compile = lambda do |input|
-      form = @read.call(input)
-      Rouge::Compiler.compile(@ns, Set.new, form)
-    end
-  end
+  let(:compile) { lambda {|input|
+    form = read.(input)
+    Rouge::Compiler.compile(ns, Set.new, form)
+  } }
 
   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
+    it { expect { compile.("(fn [] a)")
+                }.to raise_exception(Rouge::Namespace::VarNotFoundError) }
+
+    it { expect { compile.("q")
+                }.to raise_exception(Rouge::Namespace::VarNotFoundError) }
+
+    it { expect { compile.("(let [x 8] x)").should eq read.("(let [x 8] x)")
+                }.to_not raise_exception }
+
+    it { expect { compile.("(let [x 8] y)")
+                }.to raise_exception(Rouge::Namespace::VarNotFoundError) }
+
+    it { expect { compile.("(let [x 8] ((fn [& b] (b)) | [e] e))")
+                }.to_not raise_exception }
+
+    it { expect { compile.("(let [x 8] ((fn [& b] (b)) | [e] f))")
+                }.to raise_exception(Rouge::Namespace::VarNotFoundError) }
   end
 
   describe "macro behaviour" do
-    it "should execute macro calls when compiling" do
-      @ns.set_here :thingy, Rouge::Macro[lambda {|f|
+    before 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
+
+    it do
+      compile.("(let [list 'thing] (thingy (1 2 3)))").
+          should eq read.("(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>")
+    it do
+      x = double("class")
       x.stub(:new => nil)
 
-      @ns.set_here :x, x
-      x_new = @compile.call("x.")
+      ns.set_here(:x, x)
+      x_new = compile.("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?")
+    context "var in context ns" do
+      before { ns.set_here(:tiffany, "wha?") }
+      it { compile.("tiffany").res.
+             should eq Rouge::Var.new(:"user.spec", :tiffany, "wha?") }
+    end
+
+    context "vars in referred ns" do
+      subject { compile.("def").res }
+      it { should be_an_instance_of Rouge::Var }
+      its(:ns) { should eq :"rouge.builtin" }
+      its(:name) { should eq :def }
+      its(:deref) { should be_an_instance_of(Rouge::Builtin) }
     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)
+    context "var in qualified ns" do
+      subject { compile.("ruby/Kernel").res }
+      it { should be_an_instance_of Rouge::Var }
+      its(:ns) { should eq :ruby }
+      its(:name) { should eq :Kernel }
+      its(:deref) { should eq Kernel }
     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
+    context "class instantiation" do
+      subject { compile.("ruby/String.").res }
+      it { should be_an_instance_of Method }
+      its(:receiver) { should eq String }
+      its(:name) { should eq :new }
     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
+    context "static method lookup" do
+      context "implied ns" do
+        before { ns.set_here(:String, String) }
+        subject { compile.("String/new").res }
+        it { should be_an_instance_of Method }
+        its(:receiver) { should eq String }
+        its(:name) { should eq :new }
+      end
+
+      context "fully-qualified" do
+        subject { compile.("ruby/String/new").res }
+        it { should be_an_instance_of Method }
+        its(:receiver) { should eq String }
+        its(:name) { should eq :new }
+      end
     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
+    it { expect { compile.("[a]")
+                }.to raise_exception(Rouge::Namespace::VarNotFoundError) }
+
+    context do
+      before { ns.set_here(:a, :a) }
+      it { expect { compile.("[a]")
+                  }.to_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)))")
+    it { expect { compile.("{b c}")
+                }.to raise_exception(Rouge::Namespace::VarNotFoundError) }
+
+    context do
+      before { ns.set_here(:b, :b) }
+      it { expect { compile.("{b c}")
+                  }.to raise_exception(Rouge::Namespace::VarNotFoundError) }
+
+      context do
+        before { ns.set_here(:c, :c) }
+        it { expect { compile.("{b c}")
+                    }.to_not raise_exception }
+      end
     end
 
-    it { @compile.call("()").should eq Rouge::Seq::Empty }
+    it { compile.("(let [a 'thing] (a | [b] b))").
+           should eq read.("(let [a 'thing] (a | (fn [b] b)))") }
+
+    it { compile.("()").should eq Rouge::Seq::Empty }
   end
 end
 

data/spec/namespace_spec.rb

@@ -46,7 +46,7 @@ describe Rouge::Namespace do
       abc = Rouge::Namespace.new :abc
       xyz = Rouge::Namespace.new :xyz
 
-      xyz.refer abc
+      xyz.refer(abc).should be xyz
 
       abc.set_here :hello, :wow
       xyz[:hello].deref.should eq :wow

data/spec/reader_spec.rb

@@ -175,6 +175,32 @@ describe Rouge::Reader do
     end
   end
 
+  describe "sets" do
+    context "the empty set" do
+      it { @ns.read('#{}').should eq Set.new }
+    end
+
+    context "multiple-element sets" do
+      it { @ns.read('#{1 2 3}').should eq Set.new.add(1).add(2).add(3) }
+      it { @ns.read('#{true () [] "no"}').
+           should eq Set.new([Rouge::Symbol[:true],
+                              Rouge::Seq::Cons[],
+                              [],
+                              "no"]) }
+    end
+
+    context "nested sets" do
+      it { @ns.read('#{#{1} #{2} #{3}}').
+            should eq Set.new([Set.new([1]), Set.new([2]), Set.new([3])]) }
+    end
+
+    context "read as frozen" do
+      it { @ns.read('#{}').should be_frozen }
+      it { @ns.read('#{1}').should be_frozen }
+      it { @ns.read('#{1 2}').should be_frozen }
+    end
+  end
+
   describe "quotations" do
     it { @ns.read("'x").
            should eq Rouge::Seq::Cons[Rouge::Symbol[:quote],

data/spec/seq_spec.rb

@@ -13,7 +13,7 @@ describe Rouge::Seq::ASeq do
   describe "#seq" do
     it "should return the original object" do
      seq.seq.should be seq
-    end 
+    end
   end
 
   describe "the unimplemented methods" do
@@ -196,6 +196,30 @@ describe Rouge::Seq do
       let(:arrayseq) { Rouge::Seq::Array.new([:a], 0) }
       it { Rouge::Seq.seq(arrayseq).should be arrayseq }
     end
+
+    context Set do
+      subject { Rouge::Seq.seq(Set.new([1, 2, 3])) }
+      it { should be_an_instance_of Rouge::Seq::Array }
+      it { should eq Rouge::Seq::Array.new([1, 2, 3], 0) }
+    end
+
+    context Hash do
+      subject { Rouge::Seq.seq({:a => "a", :b => "b"}) }
+      it { should be_an_instance_of Rouge::Seq::Array }
+      it { should eq Rouge::Seq::Array.new([[:a, "a"], [:b, "b"]], 0) }
+    end
+
+    context String do
+      subject { Rouge::Seq.seq("foo") }
+      it { should be_an_instance_of Rouge::Seq::Array }
+      it { should eq Rouge::Seq::Array.new(['f', 'o', 'o'], 0) }
+    end
+
+    context Enumerator do
+      subject { Rouge::Seq.seq(1.upto(3)) }
+      it { should be_an_instance_of Rouge::Seq::Array }
+      it { should eq Rouge::Seq::Array.new([1, 2, 3], 0) }
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge-lang
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-12 00:00:00.000000000 Z
+date: 2012-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -186,15 +186,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -862515277
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -862515277
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: An implementation of Clojure for Ruby.