rouge-lang 0.0.9 → 0.0.10

data/lib/rouge/printer.rb

@@ -6,82 +6,49 @@ module Rouge::Printer
 
   def self.print(form, out)
     case form
-    when Integer
+    when Numeric
+      # Handles Integer, Float, Rational, and Complex instances.
       out << form.to_s
-    when Rational
-      out << "#{form.numerator}/#{form.denominator}"
-    when Rouge::Symbol
-      if form.ns_s
-        out << form.ns_s
-        out << "/"
-      end
-      out << form.name_s
-    when Symbol
-      out << form.inspect
-    when String
-      out << form.inspect
     when Array
-      out << "["
-      form.each.with_index do |e, i|
-        out << " " unless i.zero?
-        print(e, out)
-      end
-      out << "]"
-    when Rouge::Seq::Empty
-      out << "()"
-    when Rouge::Seq::Cons
-      if form.length == 2 and form[0] == Rouge::Symbol[:quote]
-        out << "'"
-        print(form[1], out)
-      elsif form.length == 2 and form[0] == Rouge::Symbol[:var]
-        out << "#'"
-        print(form[1], out)
-      else
-        out << "("
-        form.each.with_index do |e, i|
-          out << " " unless i.zero?
-          print(e, out)
-        end
-        out << ")"
-      end
-    when Rouge::Var
-      out << "#'#{form.ns}/#{form.name}"
+      out << "[#{print_collection(form)}]"
     when Hash
-      out << "{"
-      form.each.with_index do |kv,i|
-        out << ", " unless i.zero?
-        print(kv[0], out)
-        out << " "
-        print(kv[1], out)
-      end
-      out << "}"
+      out << "{#{print_collection(form)}}"
     when Set
-      out << "\#{"
-      form.each_with_index do |el, i|
-        print el, out
-        out << " " unless i == (form.size - 1)
+      out << "\#{#{print_collection(form)}}"
+    when Regexp
+      out << "#\"#{form.source}\""
+    when Symbol
+      # Symbols containing white space are printed with the results of #inspect,
+      # otherwise they are printed with the results #to_s. This maintains an
+      # experience consistent with Clojure whenever possible while providing
+      # clarity in cases where Symbols contain white space, although this is
+      # typically uncommon.
+      if /\s/.match(form)
+        out << form.inspect
+      else
+        out << ":#{form}"
       end
-      out << "}"
-    when NilClass
-      out << "nil"
-    when TrueClass
-      out << "true"
-    when FalseClass
-      out << "false"
+    when Rouge::Builtin, Rouge::Symbol, Rouge::Var, Rouge::Seq::Empty, Rouge::Seq::Cons
+      out << form.to_s
     when Class, Module
       if form.name
         out << "ruby/#{form.name.split('::').join('.')}"
       else
         out << form.inspect
       end
-    when Rouge::Builtin
-      out << "rouge.builtin/#{form.inner.name}"
-    when Regexp
-      out << "#\"#{form.source}\""
     else
       out << form.inspect
     end
   end
+
+  # Prints a collection of elements using `print`.
+  def self.print_collection(collection)
+    if collection.is_a? Hash
+      collection.to_a.map {|pair| print_collection(pair) }.join(', ')
+    else
+      collection.map {|el| print(el, '') }.join(' ')
+    end
+  end
 end
 
 # vim: set sw=2 et cc=80:

data/lib/rouge/seq.rb

@@ -16,7 +16,6 @@ module Rouge::Seq
   # A partial implementation of ISeq.  You supply #first and #next, it gives:
   #
   #  - #cons
-  #  - #inspect
   #  - #to_s
   #  - #seq
   #  - #length (#count)
@@ -28,13 +27,13 @@ module Rouge::Seq
   module ASeq
     include ISeq
 
-    def inspect
-      "(#{to_a.map(&:inspect).join " "})"
+    def to_s
+      "(#{to_a.map(&:to_s).join " "})"
     end
 
-    def to_s; inspect; end
-
-    def seq; self; end
+    def seq
+      self
+    end
 
     def first; raise NotImplementedError; end
     def next; raise NotImplementedError; end
@@ -84,13 +83,13 @@ module Rouge::Seq
       cursor.first
     end
 
-    def ==(seq)
-      if seq.is_a?(ISeq)
-        return self.to_a == seq.to_a
+    def ==(other)
+      if other.is_a?(ISeq)
+        return self.to_a == other.to_a
       end
 
-      if seq.is_a?(::Array)
-        return self.to_a == seq
+      if other.is_a?(::Array)
+        return self.to_a == other
       end
 
       false
@@ -128,8 +127,9 @@ module Rouge::Seq
   class << Empty
     include ASeq
 
-    def inspect; "()"; end
-    def to_s; inspect; end
+    def to_s
+      '()'
+    end
 
     def seq; nil; end
     def first; nil; end
@@ -145,8 +145,10 @@ module Rouge::Seq
   class Cons
     include ASeq
 
+    attr_reader :head, :tail
+
     def initialize(head, tail)
-      if tail and !tail.is_a?(ISeq)
+      if tail && !tail.is_a?(ISeq)
         raise ArgumentError,
             "tail should be an ISeq, not #{tail.inspect} (#{tail.class})"
       end
@@ -154,11 +156,27 @@ module Rouge::Seq
       @head, @tail = head, tail
     end
 
-    def first; @head; end
-    def next; Rouge::Seq.seq @tail; end
+    def first
+      @head
+    end
+
+    def next
+      Rouge::Seq.seq(@tail)
+    end
+
+    def to_s
+      if self.length == 2 && self[0] == Rouge::Symbol[:quote]
+        "'#{self[1]}"
+      elsif self.length == 2 && self[0] == Rouge::Symbol[:var]
+        "#'#{self[1]}"
+      else
+        "(#{Rouge::Printer.print_collection(self)})"
+      end
+    end
 
     def self.[](*elements)
       length = elements.length
+
       return Empty if length.zero?
 
       head = nil
@@ -168,8 +186,6 @@ module Rouge::Seq
 
       head.freeze
     end
-
-    attr_reader :head, :tail
   end
 
   # A seq over a Ruby Array.
@@ -240,8 +256,13 @@ module Rouge::Seq
       seq.send(sym, *args, &block)
     end
 
-    def inspect; seq.inspect; end
-    def to_s; seq.to_s; end
+    def inspect
+      seq.inspect
+    end
+
+    def to_s
+      seq.to_s
+    end
   end
 
   # An error thrown when we try to do a seq operation on something that's not
@@ -260,14 +281,10 @@ module Rouge::Seq
       else
         Rouge::Seq::Array.new(form, 0)
       end
-    when Enumerator
+    when Hash, Set, Enumerator
       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/symbol.rb

@@ -4,13 +4,15 @@ require 'rouge/metadata'
 class Rouge::Symbol
   include Rouge::Metadata
 
+  attr_reader :ns, :name, :ns_s, :name_s, :name_parts, :new_sym
+
   # The symbols for t/f/n are the Ruby objects themselves.
   LOOKUP = {
     :true => true,
     :false => false,
     :nil => nil,
   }
-  
+
   KNOWNS = {
     :/ => [nil, :/],
     :"./" => [nil, :"./"],
@@ -58,20 +60,20 @@ class Rouge::Symbol
   end
 
   def to_sym
-    :"#{@ns ? "#@ns/" : ""}#@name"
+    :"#{to_s}"
   end
 
   def inspect
     "Rouge::Symbol[#{to_sym.inspect}]"
   end
 
-  def to_s; inspect; end
+  def to_s
+    "#{@ns ? "#@ns/" : ""}#@name"
+  end
 
   def ==(right)
     right.is_a?(Rouge::Symbol) and right.ns == @ns and right.name == @name
   end
-
-  attr_reader :ns, :name, :ns_s, :name_s, :name_parts, :new_sym
 end
 
 # vim: set sw=2 et cc=80:

data/lib/rouge/var.rb

@@ -1,29 +1,31 @@
 # encoding: utf-8
 
 class Rouge::Var
+  attr_reader :ns, :name
+
   @@stack = []
 
   def initialize(ns, name, root=Rouge::Var::UnboundSentinel)
-    @ns = ns
-    @name = name
     raise ArgumentError, "bad var ns" unless ns.is_a? Symbol
     raise ArgumentError, "bad var name" unless name.is_a? Symbol
+
+    @ns = ns
+    @name = name
+
     if root == Rouge::Var::UnboundSentinel
-      @root = Rouge::Var::Unbound.new self
+      @root = Rouge::Var::Unbound.new(self)
     else
       @root = root
     end
   end
 
-  def ==(var)
-    var.is_a?(Rouge::Var) and @ns == var.ns and @name == var.name
+  def ==(other)
+    other.is_a?(Rouge::Var) && @ns == other.ns && @name == other.name
   end
 
-  attr_reader :ns, :name
-  
   def deref
     @@stack.reverse_each do |map|
-      if map.include? @name
+      if map.include?(@name)
         return map[@name]
       end
     end
@@ -32,11 +34,11 @@ class Rouge::Var
   end
 
   def inspect
-    "Rouge::Var.new(#{@ns.inspect}, #{@name.inspect}, #{@root.inspect})"
+    "#<Rouge::Var: (#{@ns.inspect}, #{@name.inspect}, #{@root.inspect})>"
   end
 
   def to_s
-    inspect
+    "#'#@ns/#@name"
   end
 
   def self.push(map)
@@ -48,22 +50,26 @@ class Rouge::Var
   end
 end
 
-Rouge::Var::UnboundSentinel = Object.new
-class << Rouge::Var::UnboundSentinel
-  def inspect; "#<Rouge::Var::UnboundSentinel>"; end
-  def to_s; inspect; end
+class Rouge::Var::UnboundSentinel
+  def self.inspect
+    "#<Rouge::Var::UnboundSentinel>"
+  end
 end
 
 class Rouge::Var::Unbound
+  attr_reader :var
+
   def initialize(var)
     @var = var
   end
 
-  def ==(ub)
-    @var == ub.var
+  def ==(other)
+    @var == other.var
   end
 
-  attr_reader :var
+  def inspect
+    "#<Rouge::Var::Unbound: #@var>"
+  end
 end
 
 # vim: set sw=2 et cc=80:

data/lib/rouge/version.rb

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

data/lib/rouge/wrappers.rb

@@ -2,6 +2,8 @@
 
 [:Macro, :Builtin, :Dequote, :Splice].each do |name|
   Rouge.const_set name, Class.new {
+    attr_reader :inner
+
     def initialize(inner)
       @inner = inner
     end
@@ -14,14 +16,16 @@
       "#{self.class.name}[#{@inner.inspect}]"
     end
 
-    def to_s; inspect; end
-
     def ==(right)
       right.is_a?(self.class) and right.inner == @inner
     end
-
-    attr_reader :inner
   }
 end
 
+class Rouge::Builtin
+  def to_s
+    "rouge.builtin/#{inner.name}"
+  end
+end
+
 # vim: set sw=2 et cc=80:

data/spec/printer_spec.rb

@@ -30,7 +30,9 @@ describe Rouge::Printer do
       end
 
       context "string-symbols" do
-        it { Rouge.print(:"!ruby!", "").should eq ":\"!ruby!\"" }
+        it { Rouge.print(:"!ruby!", "").should eq ":!ruby!" }
+        it { Rouge.print(:"lady-bird", "").should eq ":lady-bird" }
+        it { Rouge.print(:"bean sprouts", "").should eq ":\"bean sprouts\"" }
       end
     end
 

data/spec/seq_spec.rb

@@ -110,12 +110,12 @@ describe Rouge::Seq::Cons do
                   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)" }
+  describe "#to_s" do
+    it { Rouge::Seq::Cons[].to_s.should eq "()" }
+    it { Rouge::Seq::Cons[1].to_s.should eq "(1)" }
+    it { Rouge::Seq::Cons[1, 2].to_s.should eq "(1 2)" }
+    it { Rouge::Seq::Cons[1, 2, 3].to_s.should eq "(1 2 3)" }
+    it { Rouge::Seq::Cons[1, 2, 3].tail.to_s.should eq "(2 3)" }
   end
 
   describe "the ASeq implementation" do

data/spec/symbol_spec.rb

@@ -30,6 +30,11 @@ describe Rouge::Symbol do
     it { Rouge::Symbol[:boo].to_sym.should eq :boo }
     it { Rouge::Symbol[:"what/nice"].to_sym.should eq :"what/nice" }
   end
+
+  describe "#to_s" do
+    it { Rouge::Symbol[:"breakfast"].to_s.should eq "breakfast" }
+    it { Rouge::Symbol[:"breakfast/toast"].to_s.should eq "breakfast/toast" }
+  end
 end
 
 # vim: set sw=2 et cc=80:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rouge-lang
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-28 00:00:00.000000000 Z
+date: 2013-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -188,7 +188,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -574578803
+      hash: -185805507
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -197,7 +197,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -574578803
+      hash: -185805507
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24