shen-ruby 0.10.0 → 0.11.0

data/spec/kl/lexer_spec.rb

@@ -1,149 +0,0 @@
-require 'spec_helper'
-
-describe Kl::Lexer do
-  def lexer(str)
-    Kl::Lexer.new(StringIO.new(str))
-  end
-
-  describe 'syntax tokens' do
-    it 'reads ( as a Kl::Lexer::OpenParen' do
-      lexer("(").next.should be_kind_of Kl::Lexer::OpenParen
-    end
-
-    it 'reads ) as a Kl::Lexer::CloseParen' do
-      lexer(")").next.should be_kind_of Kl::Lexer::CloseParen
-    end
-  end
-
-  describe 'string tokens' do
-    it 'reads double-quoted strings' do
-      lexer('"Fred"').next.should == "Fred"
-    end
-
-    it 'throws Kl::Error on unterminated strings' do
-      expect {
-        lexer('"Fred').next
-      }.to raise_error(Kl::Error, "unterminated string")
-    end
-  end
-
-  describe 'symbols' do
-    it 'reads sign characters not followed by digits as symbols' do
-      lexer('-').next.should == '-'.to_sym
-      lexer('+').next.should == '+'.to_sym
-      lexer('--+-').next.should == '--+-'.to_sym
-    end
-
-    it 'reads double decimal points followed by digits as symbols' do
-      lexer('..77').next.should == '..77'.to_sym
-    end
-
-    it "accepts =-*/+_?$!@~><&%'#`;:{} in symbols" do
-      all_punctuation = "=-*/+_?$!@~><&%'#`;:{}"
-      sym = lexer(all_punctuation).next
-      sym.should be_kind_of Symbol
-      sym.to_s.should == all_punctuation
-    end
-  end
-
-  describe 'numbers' do
-    it 'reads integers as Fixnums' do
-      num = lexer("37").next
-      num.should be_kind_of Fixnum
-      num.should == 37
-    end
-    
-    it 'reads floating points as Floats' do
-      num = lexer("37.42").next
-      num.should be_kind_of Float
-      num.should == 37.42
-    end
-
-    it 'with an odd number of leading minuses are negative' do
-      lexer('-1').next.should == -1
-      lexer('---1').next.should == -1
-    end
-
-    it 'with an even number of leading minuses are positive' do
-      lexer('--1').next.should == 1
-      lexer('----1').next.should == 1
-    end
-
-    it 'with leading + does not change sign' do
-      lexer('+-1').next.should == -1
-      lexer('-+--1').next.should == -1
-      lexer('-+-+1').next.should == 1
-      lexer('+-+-+-+-+1').next.should == 1
-    end
-
-    it 'allows leading decimal points' do
-      lexer('.9').next.should == 0.9
-      lexer('-.9').next.should == -0.9
-    end
-
-    it 'treats a trailing decimal followed by EOF as a symbol' do
-      l = lexer('7.')
-      num = l.next
-      num.should be_kind_of Fixnum
-      num.should == 7
-
-      sym = l.next
-      sym.should be_kind_of Symbol
-      sym.to_s.should == '.'
-    end
-
-    it 'treats a trailing decimal followed by non-digit as a symbol' do
-      l = lexer('7.a')
-      num = l.next
-      num.should be_kind_of Fixnum
-      num.should == 7
-
-      sym = l.next
-      sym.should be_kind_of Symbol
-      sym.to_s.should == '.a'
-    end
-
-    it 'handles multiple decimal points like shen does' do
-      l = lexer('7.8.9')
-      l.next.should == 7.8
-      l.next.should == 0.9
-    end
-  end
-
-  describe 'booleans' do
-    it 'reads true as boolean true' do
-      lexer('true').next.should be_kind_of TrueClass
-    end
-
-    it 'reads false as boolean false' do
-      lexer('false').next.should be_kind_of FalseClass
-    end
-  end
-
-  describe 'whitespace' do
-    it 'is ignored between tokens' do
-      l = lexer("     (\n\t)   ")
-      l.next.should be_kind_of Kl::Lexer::OpenParen
-      l.next.should be_kind_of Kl::Lexer::CloseParen
-      l.next.should be_nil
-    end
-
-    it 'is left intact in strings' do
-      lexer('     "one two"   ').next.should == "one two"
-    end
-  end
-
-  it 'works with these all together' do
-    l = lexer('(12 quick m-*$ RAN `fast\' -.7) "oh 12 yeah!"  ')
-    l.next.should be_kind_of Kl::Lexer::OpenParen
-    l.next.should == 12
-    l.next.should == :quick
-    l.next.should == 'm-*$'.to_sym
-    l.next.should == :RAN
-    l.next.should == "`fast'".to_sym
-    l.next.should == -0.7
-    l.next.should be_kind_of Kl::Lexer::CloseParen
-    l.next.should == "oh 12 yeah!"
-    l.next.should be_nil
-  end
-end

data/spec/kl/primitives/generic_functions_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-require 'kl/primitives/generic_functions'
-
-describe Kl::Primitives::GenericFunctions do
-  include Kl::Primitives::GenericFunctions
-
-  describe '=' do
-    it 'works as expected for numbers' do
-      self.send("=", 1, 1).should be_true
-      self.send("=", 1, 1.0).should be_true
-      self.send("=", 1, 2).should be_false
-    end
-
-    it 'works as expected for symbols' do
-      self.send("=", :a, :a).should be_true
-      self.send("=", :"big-bad!", :"big-bad!").should be_true
-      self.send("=", :"big-bad!", :wolf).should be_false
-    end
-
-    it 'works as expected for lists' do
-      self.send("=", Kl::Cons.list([1, 2]), Kl::Cons.list([1, 2])).
-        should be_true
-      self.send("=", Kl::EmptyList.instance, Kl::EmptyList.instance).
-        should be_true
-      self.send("=", Kl::Cons.list([1, 3]), Kl::Cons.list([1, 2])).
-        should be_false
-    end
-  end
-end

data/spec/kl/primitives/symbols_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'kl/primitives/symbols'
-
-describe Kl::Primitives::Symbols do
-  include Kl::Primitives::Symbols
-
-  describe "intern" do
-    it "returns boolean true for 'true'" do
-      intern("true").should == true
-    end
-
-    it "returns boolean false for 'false'" do
-      intern("false").should == false
-    end
-
-    it "returns the symbol corresponding to the string otherwise" do
-      intern("abc-123").should == :"abc-123"
-    end
-  end
-end
-

data/spec/kl/reader_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Kl::Reader do
-  def reader(str)
-    Kl::Reader.new(StringIO.new(str))
-  end
-
-  describe 'Reading lists' do
-    it 'reads () as an empty list' do
-      reader('()').next.should be_kind_of Kl::EmptyList
-    end
-
-    it 'reads a list as a single expression' do
-      list = reader('(1 2 3)').next
-      list.should == Kl::Cons.list([1, 2, 3])
-    end
-
-    it 'supports nested lists' do
-      list = reader('(1 (2 (3) ()))').next
-      list.should == Kl::Cons.list([1, 
-                                    Kl::Cons.list([2, 
-                                                   Kl::Cons.list([3]),
-                                                   Kl::EmptyList.instance])])
-    end
-
-    it 'raises an error on unterminated lists' do
-      expect {
-        reader('(1').next
-      }.to raise_error(Kl::Error, 'Unterminated list')
-    end
-  end
-
-  describe 'Reading booleans' do
-    it 'reads true as true' do
-      reader('true').next.should == true
-    end
-
-    it 'reads false as false' do
-      reader('false').next.should == false
-    end
-  end
-end