nydp 0.0.2 → 0.0.3

data/spec/nypd_spec.rb

@@ -1,33 +1,12 @@
 require 'spec_helper'
 
 describe Nydp do
-  let(:root_ns)               { { } }
-  let(:parser)                { Nydp::Parser.new(root_ns) }
+  let(:parser)                { Nydp::Parser.new(ns) }
   let(:vm)                    { Nydp::VM.new }
 
-  def sym name
-    Nydp::Symbol.mk name.to_sym, root_ns
-  end
-
-  def parse txt
-    tokens = Nydp::Tokeniser.new txt
-    expressions = []
-    expr = parser.expression(tokens)
-    while (expr != nil)
-      expressions << expr
-      expr = parser.expression(tokens)
-    end
-    expressions
-  end
-
   def run txt
-    Nydp.setup root_ns
-    expressions = parse(txt)
-    result = nil
-    expressions.each do |expr|
-      result = Nydp.compile_and_eval vm, expr
-    end
-    result
+    Nydp.setup ns
+    Nydp::StreamRunner.new(vm, ns, txt).run
   end
 
   it "should make a symbol from a string" do
@@ -101,9 +80,9 @@ describe Nydp do
   end
 
   it "should recurse without consuming extra memory" do
-    program = "(assign f1 (fn (x acc) (cond (< x 1) (vm-info) (f1 (- x 1) (+ x acc))))) (f1 1000)"
+    program = "(assign f1 (fn (x acc) (cond (< x 1) (vm-info) (f1 (- x 1) (+ x acc))))) (f1 1000 0)"
     expected = parse "((contexts . 0) (instructions . 0) (args . 0))"
-    expect(run program).to eq expected.first
+    expect(run program).to eq expected
   end
 
   describe :cond do

data/spec/pair_spec.rb

@@ -1,7 +1,6 @@
 require "spec_helper"
 
 describe Nydp::Pair do
-  let(:ns)               { { } }
   let(:a)                { Nydp::Symbol.mk :a,                  ns }
   let(:b)                { Nydp::Symbol.mk :b,                  ns }
   let(:c)                { Nydp::Symbol.mk :c,                  ns }
@@ -23,26 +22,26 @@ describe Nydp::Pair do
     end
 
     it "should define #== to return true for an identical list" do
-      p1 = Nydp::Pair.from_list [:a, :b, :c, :d]
-      p2 = Nydp::Pair.from_list [:a, :b, :c, :d]
+      p1 = pair_list [:a, :b, :c, :d]
+      p2 = pair_list [:a, :b, :c, :d]
       expect(p1).to eq p2
     end
 
     it "should define #== to return true for identical improper lists" do
-      p1 = Nydp::Pair.from_list [:a, :b, :c, :d], 4
-      p2 = Nydp::Pair.from_list [:a, :b, :c, :d], 4
+      p1 = pair_list [:a, :b, :c, :d], 4
+      p2 = pair_list [:a, :b, :c, :d], 4
       expect(p1).to eq p2
     end
 
     it "should define #== to return false for a non-identical list" do
-      p1 = Nydp::Pair.from_list [:a, :b, :c, :d]
-      p2 = Nydp::Pair.from_list [:a, :b, :c, 22]
+      p1 = pair_list [:a, :b, :c, :d]
+      p2 = pair_list [:a, :b, :c, 22]
       expect(p1).not_to eq p2
     end
 
     it "should define #== to return false for lists which differ only in their terminating element" do
-      p1 = Nydp::Pair.from_list [:a, :b, :c], :d
-      p2 = Nydp::Pair.from_list [:a, :b, :c], 22
+      p1 = pair_list [:a, :b, :c], :d
+      p2 = pair_list [:a, :b, :c], 22
       expect(p1).not_to eq p2
     end
   end
@@ -54,7 +53,7 @@ describe Nydp::Pair do
   end
 
   it "should convert a ruby list" do
-    p = Nydp::Pair.from_list [:a, :b, :c, :d]
+    p = pair_list [:a, :b, :c, :d]
     expect(p.car).to eq :a
     p = p.cdr
     expect(p.car).to eq :b
@@ -71,32 +70,32 @@ describe Nydp::Pair do
   end
 
   it "should have size zero when empty" do
-    expect(Nydp::Pair.from_list([]).size).to eq 0
+    expect(pair_list([]).size).to eq 0
   end
 
   it "should report the number of elements is contains" do
-    expect(Nydp::Pair.from_list([:a, :b, :c]).size).to eq 3
+    expect(pair_list([:a, :b, :c]).size).to eq 3
   end
 
   it "should report the number of elements in an improper list, excluding last item" do
-    expect(Nydp::Pair.from_list([:a, :b, :c, :d], :foo).size).to eq 4
+    expect(pair_list([:a, :b, :c, :d], :foo).size).to eq 4
   end
 
   it "should represent itself as a string" do
-    expect(Nydp::Pair.from_list([a, b, c, d]).to_s).to eq "(a b c d)"
+    expect(pair_list([a, b, c, d]).to_s).to eq "(a b c d)"
   end
 
   it "should represent an improper list as a string" do
-    expect(Nydp::Pair.from_list([a, b, c, d], foo).to_s).to eq "(a b c d . foo)"
+    expect(pair_list([a, b, c, d], foo).to_s).to eq "(a b c d . foo)"
   end
 
   it "should parse a list" do
-    p = Nydp::Pair.from_list [a, b, c, d]
+    p = pair_list [a, b, c, d]
     expect(Nydp::Pair.parse_list([a, b, c, d])).to eq p
   end
 
   it "should parse a list" do
-    p = Nydp::Pair.from_list [a, b, c, d], foo
+    p = pair_list [a, b, c, d], foo
     expect(Nydp::Pair.parse_list([a, b, c, d, dot, foo])).to eq p
   end
 end

data/spec/parser_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe Nydp::Parser do
-
-  let(:ns)               { { } }
   let(:aa)               { Nydp::Symbol.mk :aa,                   ns }
   let(:a)                { Nydp::Symbol.mk :a,                    ns }
   let(:b)                { Nydp::Symbol.mk :b,                    ns }
@@ -21,18 +19,6 @@ describe Nydp::Parser do
   let(:cocosyn)          { Nydp::Symbol.mk :"colon-colon-syntax", ns }
   let(:colosyn)          { Nydp::Symbol.mk :"colon-syntax",       ns }
 
-  def sym name
-    Nydp::Symbol.mk name.to_sym, ns
-  end
-
-  def parse txt
-    Nydp::Parser.new(ns).expression(Nydp::Tokeniser.new txt)
-  end
-
-  def pair_list xs, last=Nydp.NIL
-    Nydp::Pair.from_list xs, last
-  end
-
   it "should return a stream of tokens" do
     t = Nydp::Tokeniser.new ""
     expect(t.next_token).to eq nil
@@ -120,6 +106,16 @@ describe Nydp::Parser do
     expect(parse '(1 "hello there \"jimmy\"" 3)').to eq expected
   end
 
+  it "should handle escaped tabs and newlines inside a string" do
+    expected = Nydp::StringAtom.new "hello\tworld\nnice day"
+    parsed = parse "\"hello\\tworld\\nnice day\""
+    expect(parsed).to eq expected
+  end
+
+  it "should parse a brace list" do
+    expect(parse "{a b c d}").to eq pair_list [sym("brace-list"), a, b, c, d]
+  end
+
   it "should parse a plain symbol" do
     expect(parse "foo").to eq foo
   end
@@ -128,6 +124,10 @@ describe Nydp::Parser do
     expect(parse "foo.bar").to eq  pair_list([dotsyn, foo, bar])
   end
 
+  it "should parse a dotted symbol" do
+    expect(parse "(list a b foo.bar c)").to eq  pair_list([sym(:list), a, b, pair_list([dotsyn, foo, bar]), c])
+  end
+
   it "should parse a colon-colon symbol" do
     expect(parse "foo::bar").to eq  pair_list([cocosyn, foo, bar])
   end

data/spec/spec_helper.rb

@@ -1,10 +1,29 @@
 require 'nydp'
 require 'nydp/symbol'
 
+module SpecHelper
+  def sym name
+    Nydp::Symbol.mk name.to_sym, ns
+  end
+
+  def parse txt
+    Nydp::Parser.new(ns).expression(Nydp::Tokeniser.new txt)
+  end
+
+  def pair_list xs, last=Nydp.NIL
+    Nydp::Pair.from_list xs, last
+  end
+
+  def self.included base
+    base.let(:ns)  { { } }
+  end
+end
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
   config.order = 'random'
   config.include Nydp::Helper
+  config.include SpecHelper
 end

data/spec/string_token_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Nydp::StringFragmentToken do
+  it "is equal to another token with the same content" do
+    t1 = Nydp::StringFragmentToken.new "foo", "bar"
+    t2 = Nydp::StringFragmentToken.new "foo", "zub"
+    expect(t1).to eq t2
+  end
+
+  it "is not equal to another string with the same content" do
+    t1 = Nydp::StringFragmentToken.new "foo", "bar"
+    expect(t1).not_to eq "foo"
+  end
+
+  it "is not equal to nil" do
+    t1 = Nydp::StringFragmentToken.new "foo", "bar"
+    expect(t1).not_to eq Nydp.NIL
+  end
+end

data/spec/symbol_spec.rb

@@ -1,8 +1,6 @@
 require 'spec_helper'
 
 describe Nydp::Symbol do
-  let(:ns) { { } }
-
   it "should not recognise an unknown symbol" do
     sym = Nydp::Symbol.find :foo, ns
     expect(sym).to eq nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nydp
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-01 00:00:00.000000000 Z
+date: 2015-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -110,14 +110,18 @@ files:
 - lib/nydp/builtin/puts.rb
 - lib/nydp/builtin/quit.rb
 - lib/nydp/builtin/random_string.rb
+- lib/nydp/builtin/string_replace.rb
+- lib/nydp/builtin/string_split.rb
 - lib/nydp/builtin/times.rb
 - lib/nydp/builtin/to_string.rb
 - lib/nydp/builtin/to_sym.rb
+- lib/nydp/builtin/type_of.rb
 - lib/nydp/builtin/vm_info.rb
 - lib/nydp/closure.rb
 - lib/nydp/compiler.rb
 - lib/nydp/cond.rb
 - lib/nydp/context_symbol.rb
+- lib/nydp/core.rb
 - lib/nydp/error.rb
 - lib/nydp/function_invocation.rb
 - lib/nydp/helper.rb
@@ -126,6 +130,7 @@ files:
 - lib/nydp/literal.rb
 - lib/nydp/pair.rb
 - lib/nydp/parser.rb
+- lib/nydp/runner.rb
 - lib/nydp/string_atom.rb
 - lib/nydp/string_token.rb
 - lib/nydp/symbol.rb
@@ -142,6 +147,7 @@ files:
 - spec/pair_spec.rb
 - spec/parser_spec.rb
 - spec/spec_helper.rb
+- spec/string_token_spec.rb
 - spec/symbol_spec.rb
 homepage: http://github.com/conanite/nydp
 licenses:
@@ -174,4 +180,5 @@ test_files:
 - spec/pair_spec.rb
 - spec/parser_spec.rb
 - spec/spec_helper.rb
+- spec/string_token_spec.rb
 - spec/symbol_spec.rb