nydp 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33480122f9608ad9c13fe61c3ed534ce73765ddd
-  data.tar.gz: 27712f0e21be0cb53af53fb37bb8dc89c72c71fd
+  metadata.gz: 373997c8dcd5597d8742b347ef75b0b68ef312e7
+  data.tar.gz: 69ab87494d38291aa35786f835489095ce1ccd71
 SHA512:
-  metadata.gz: f4f0fb3458cf76450c64e19cddd0dc03633108aa45cc7d1f5a72fb546d446c7e0ea435e8dc913af54efaddbb707aae8ac588a0d0f2492415e0f00ca664da4fa2
-  data.tar.gz: 9cfd74432153243de497df5e50451248dc8ae0555a2032631243b102fc1af3358ba6734530ee55fd8d467cdbb49054e1b62a5de7c13bc9fa788bdea42a8a41a2
+  metadata.gz: 801258418b77c34f8521e8dc5f6e6218156b690fa7d1fa3a584a8b77102df8af4021f56f19c27f33be944d88c8fff33443a888c25ccf6b3f20934b5cae17628e
+  data.tar.gz: 3ddf5f9e89f7159a74ef6a2f163afcbc289ca6b4330b6b1307f3be5043f97e9ec023f2ce2fc2f3aae28fb37c05bc36a6410f6ddf8610673d558034f1c37ea65b

data/Rakefile

@@ -1,4 +1,4 @@
 require "bundler/gem_tasks"
 require "nydp"
 
-Nydp.rake_tasks
+Nydp.load_rake_tasks

data/lib/lisp/boot.nydp

@@ -174,6 +174,8 @@
           acc))
 
 (def joinstr (txt things)
+     (if (no (pair? things))
+         (error "joinstr : 'things is a %%(type-of things) expected a list : %%(inspect things)"))
      (apply +
             (to-string (car things))
             (flatten (zip (map (fn (_) txt) (cdr things))
@@ -217,3 +219,12 @@
               (pair? y)
               (iso (car x) (car y))
               (iso (cdr x) (cdr y)))))
+
+(def isa (type obj) (eq? (type-of obj) type))
+(mac just (arg) arg)
+(def quotify (arg) `(quote ,arg))
+
+(def len (xs)
+  (if (pair? xs)
+      (+ 1 (len (cdr xs)))
+      0))

data/lib/lisp/test-runner.nydp

@@ -5,26 +5,27 @@
   "register a test to be run later by 'run-all-tests"
   (push test all-tests))
 
-(def run-all-tests ()
+(def run-all-tests (verbose)
   "runs all tests that have been registered with 'register-test"
   (with (passed 0 failed 0)
     (with (f-pass (fn nil (assign passed (+ 1 passed)))
            f-fail (fn nil (assign failed (+ 1 failed))))
-      (run-tests `(suite "all tests" ,@all-tests) f-pass f-fail)
+      (run-tests `(suite "all tests" ,@all-tests) f-pass f-fail verbose)
       (p "passed: " passed)
       (p "failed: " failed)
       (/ passed (+ passed failed)))))
 
-(def run-tests (tests passf failf)
-  (execute-test "" tests passf failf)
+(def run-tests (tests passf failf verbose)
+  (execute-test "" tests passf failf verbose)
   results)
 
-(def execute-test (desc test passf failf)
+(def execute-test (desc test passf failf verbose)
   (if (eq? 'suite (car test))
-      (execute-tests (+ desc " - " (cadr test)) (cddr test) passf failf)
-      (execute-single-test desc test passf failf)))
+      (execute-tests (+ desc " - " (cadr test)) (cddr test) passf failf verbose)
+      (execute-single-test desc test passf failf verbose)))
 
-(def execute-single-test (desc test passf failf)
+(def execute-single-test (desc test passf failf verbose)
+  (if verbose (p desc " - " (car test)))
   (with (expected (nth 2 test) result (eval (nth 1 test)))
         (if (iso result expected)
             (passf)
@@ -34,6 +35,6 @@
 ")
                 (failf)))))
 
-(def execute-tests (desc tests passf failf)
-  (execute-test desc (car tests) passf failf)
-  (if (cdr tests) (execute-tests desc (cdr tests) passf failf)))
+(def execute-tests (desc tests passf failf verbose)
+  (execute-test desc (car tests) passf failf verbose)
+  (if (cdr tests) (execute-tests desc (cdr tests) passf failf verbose)))

data/lib/lisp/tests/foundation-test.nydp

@@ -1,4 +1,45 @@
 (register-test '(suite "Foundation Tests"
+  (suite "strings"
+    (suite "string-split"
+      ("splits a string using given expression"
+        (string-split "a and b and c and d" " and ")
+        ("a" "b" "c" "d")))
+
+    (suite "string-replace"
+      ("replaces parts of a string with the given replacement"
+        (string-replace "and" "or" "a and b and c and d")
+        "a or b or c or d"))
+
+    (suite "type-of"
+      ("returns 'string"
+        (type-of "foobar")
+        string)
+
+      ("interpolates a string"
+        "foobar %%(+ 1 2) you know"
+        "foobar 3 you know")
+
+      ("returns 'string for an interpolated string"
+        (type-of "foobar %%(+ 1 2)")
+        string)))
+
+  (suite "truth and nil"
+         ("t is boolean true"
+          (if t "hello" "goodbye")
+          "hello")
+
+         ("nil is boolean fale"
+          (if nil "hello" "goodbye")
+          "goodbye")
+
+         ("t is Truth"
+          (type-of t)
+          truth)
+
+         ("nil is nil"
+          (type-of nil)
+          nil))
+
   (suite "Lists"
     (suite "cons"
       ("cons creates a list"
@@ -7,7 +48,15 @@
 
       ("cons conses two strings"
         (cons "a" "b")
-        ("a" . "b")))
+        ("a" . "b"))
+
+      ("len returns length of proper list"
+        (len (cons "a" (cons "b" nil)))
+        2)
+
+      ("type-of returns pair"
+        (type-of (cons "a" "b"))
+        pair))
 
     (suite "car"
       ("car of nil is nil"

data/lib/nydp.rb

@@ -1,137 +1,40 @@
 module Nydp
-  LOADFILES = []
+  PLUGINS = []
 
-  def self.rake_tasks
-    load relative_path 'tasks/tests.rake'
-  end
-
-  def self.relative_path name
-    File.join File.expand_path(File.dirname(__FILE__)), name
-  end
-
-  LOADFILES << relative_path('lisp/boot.nydp')
-  LOADFILES << relative_path('lisp/test-runner.nydp')
-  Dir.glob(relative_path 'lisp/tests/**/*.nydp').each { |f| LOADFILES << f }
-
-  def self.compile_and_eval vm, expr
-    vm.thread Pair.new(Compiler.compile(expr, Nydp.NIL), Nydp.NIL)
-  end
-
-  def self.setup ns
-    Symbol.mk(:cons,  ns).assign(Nydp::Builtin::Cons.new)
-    Symbol.mk(:car,   ns).assign(Nydp::Builtin::Car.new)
-    Symbol.mk(:cdr,   ns).assign(Nydp::Builtin::Cdr.new)
-    Symbol.mk(:+,     ns).assign(Nydp::Builtin::Plus.new)
-    Symbol.mk(:-,     ns).assign(Nydp::Builtin::Minus.new)
-    Symbol.mk(:*,     ns).assign(Nydp::Builtin::Times.new)
-    Symbol.mk(:/,     ns).assign(Nydp::Builtin::Divide.new)
-    Symbol.mk(:>,     ns).assign(Nydp::Builtin::GreaterThan.new)
-    Symbol.mk(:<,     ns).assign(Nydp::Builtin::LessThan.new)
-    Symbol.mk(:eval,  ns).assign(Nydp::Builtin::Eval.new(ns))
-    Symbol.mk(:hash,  ns).assign(Nydp::Builtin::Hash.new)
-    Symbol.mk(:apply, ns).assign(Nydp::Builtin::Apply.new)
-    Symbol.mk(:error, ns).assign(Nydp::Builtin::Error.new)
-    Symbol.mk(:quit,  ns).assign(Nydp::Builtin::Quit.new)
-    Symbol.mk(:p,     ns).assign(Nydp::Builtin::Puts.new)
-    Symbol.mk(:PI,    ns).assign Literal.new(3.1415)
-    Symbol.mk(:nil,   ns).assign Nydp.NIL
-    Symbol.mk(:t,     ns).assign Nydp.T
-    Symbol.mk(:sym,   ns).assign Nydp::Builtin::ToSym.new(ns)
-    Symbol.mk(:inspect,       ns).assign(Nydp::Builtin::Inspect.new)
-    Symbol.mk(:comment,       ns).assign(Nydp::Builtin::Comment.new)
-    Symbol.mk(:millisecs,     ns).assign(Nydp::Builtin::Millisecs.new)
-    Symbol.mk("random-string",ns).assign(Nydp::Builtin::RandomString.new)
-    Symbol.mk("to-string",    ns).assign(Nydp::Builtin::ToString.new)
-    Symbol.mk(:"eq?",         ns).assign(Nydp::Builtin::IsEqual.new)
-    Symbol.mk(:"pair?",       ns).assign(Nydp::Builtin::IsPair.new)
-    Symbol.mk(:"cdr-set",     ns).assign(Nydp::Builtin::CdrSet.new)
-    Symbol.mk(:"hash-get",    ns).assign(Nydp::Builtin::HashGet.new)
-    Symbol.mk(:"hash-set",    ns).assign(Nydp::Builtin::HashSet.new)
-    Symbol.mk(:"hash-keys",   ns).assign(Nydp::Builtin::HashKeys.new)
-    Symbol.mk(:"vm-info",     ns).assign Nydp::Builtin::VmInfo.new
-    Symbol.mk(:"pre-compile", ns).assign Nydp::Builtin::PreCompile.new
-  end
-
-  class Runner
-    attr_accessor :vm, :ns
-
-    def initialize vm, ns
-      @vm = vm
-      @ns = ns
-      @precompile = Symbol.mk(:"pre-compile", ns)
-      @quote      = Symbol.mk(:quote, ns)
-    end
-
-    def quote expr
-      Pair.from_list [@quote, expr]
-    end
-
-    def precompile expr
-      Pair.from_list [@precompile, quote(expr)]
-    end
-
-    def pre_compile expr
-      Nydp.compile_and_eval(vm, precompile(expr))
-    end
-
-    def evaluate expr
-      Nydp.compile_and_eval(vm, pre_compile(expr))
-    end
-  end
-
-  class StreamRunner < Runner
-    attr_accessor :stream, :parser
-
-    def initialize vm, ns, stream
-      super vm, ns
-      @stream = stream
-      @parser = Nydp::Parser.new(ns)
-      @tokens = Nydp::Tokeniser.new stream
-    end
-
-    def prompt *_
-    end
-
-    def run
-      res = Nydp.NIL
-      prompt
-      while !@tokens.finished
-        expr = parser.expression(@tokens)
-        unless expr.nil?
-          res = evaluate expr
-          prompt res
-        end
-      end
-      res
-    end
-  end
-
-  class Repl < StreamRunner
-    def prompt val=nil
-      puts val if val
-      print "nydp > "
-    end
+  def self.plug_in plugin ; PLUGINS << plugin                   ; end
+  def self.load_rake_tasks; PLUGINS.each &:load_rake_tasks      ; end
+  def self.setup ns;        PLUGINS.each { |plg| plg.setup ns } ; end
+  def self.loadfiles;       PLUGINS.map(&:loadfiles).flatten    ; end
+  def self.testfiles;       PLUGINS.map(&:testfiles).flatten    ; end
+  def self.plugin_names   ; PLUGINS.map(&:name)                 ; end
+  def self.loadall vm, ns, files
+    files.each { |f| StreamRunner.new(vm, ns, File.new(f)).run }
   end
 
   def self.repl
     puts "welcome to nydp"
-    root_ns = { }
-    setup(root_ns)
+    ns = { }
+    setup(ns)
     vm = VM.new
-    LOADFILES.each { |f| StreamRunner.new(vm, root_ns, File.new(f)).run }
-    Repl.new(vm, root_ns, $stdin).run
+    loadall vm, ns, loadfiles
+    Repl.new(vm, ns, $stdin).run
   end
 
-  def self.tests
+  def self.tests *options
+    verbose = options.include?(:verbose) ? "t" : "nil"
     puts "welcome to nydp : running tests"
-    root_ns = { }
-    setup(root_ns)
+    ns = { }
+    setup(ns)
     vm = VM.new
-    LOADFILES.each { |f| StreamRunner.new(vm, root_ns, File.new(f)).run }
-    StreamRunner.new(vm, root_ns, "(run-all-tests)").run
+    loadall vm, ns, loadfiles
+    loadall vm, ns, testfiles
+    StreamRunner.new(vm, ns, "(run-all-tests #{verbose})").run
   end
+
 end
 
+require "nydp/core"
+require "nydp/runner"
 require "nydp/error"
 require "nydp/truth"
 require "nydp/version"

data/lib/nydp/builtin/error.rb

@@ -1,6 +1,6 @@
 class Nydp::Builtin::Error
   def invoke vm, args
     s = args.map { |a| a.to_s }
-    raise Nydp::Error.new(args.inspect)
+    raise Nydp::Error.new("#{args.inspect}\n\n#{vm.error}")
   end
 end

data/lib/nydp/builtin/inspect.rb

@@ -1,5 +1,5 @@
 class Nydp::Builtin::Inspect
   def invoke vm, args
-    vm.push_arg args.car.inspect
+    vm.push_arg Nydp::StringAtom.new(args.car.inspect)
   end
 end

data/lib/nydp/builtin/random_string.rb

@@ -2,10 +2,8 @@ class Nydp::Builtin::RandomString
   @@random_chars = ["A","B","C","D","E","F","G","H","J","K","L","M","N","P","Q","R","S","T","U","V","W","X","Y","Z","2","3","4","5","6","7","8","9"]
 
   def invoke vm, args
-    s = ""
-    1.upto(10) {
-      s << @@random_chars[rand(@@random_chars.size)]
-    }
-    Nydp::StringAtom.new s
+    length = args.car unless Nydp.NIL.is?(args)
+    s = (0...(length || 10)).map { @@random_chars[rand(@@random_chars.size)] }.join
+    vm.push_arg Nydp::StringAtom.new s
   end
 end

data/lib/nydp/builtin/string_replace.rb

@@ -0,0 +1,14 @@
+class Nydp::Builtin::StringReplace
+  def invoke vm, args
+    to_remove = args.car.to_s
+    to_insert = args.cdr.car.to_s
+    target    = args.cdr.cdr.car.to_s
+    result    = target.to_s.gsub to_remove, to_insert
+
+    vm.push_arg Nydp::StringAtom.new result
+  end
+
+  def to_s
+    "Builtin:string-replace"
+  end
+end

data/lib/nydp/builtin/string_split.rb

@@ -0,0 +1,14 @@
+class Nydp::Builtin::StringSplit
+  def invoke vm, args
+    target    = args.car.to_s
+    separator = args.cdr.car.to_s
+    result    = target.split separator
+    list      = result.map { |s| Nydp::StringAtom.new s }
+
+    vm.push_arg Nydp::Pair.from_list list
+  end
+
+  def to_s
+    "Builtin:string-split"
+  end
+end

data/lib/nydp/builtin/to_string.rb

@@ -10,3 +10,17 @@ class Nydp::Builtin::ToString
     vm.push_arg val
   end
 end
+
+class Nydp::Builtin::StringPieces
+  def to_string first, rest
+    if Nydp.NIL.is? rest
+      first.to_s
+    else
+      "#{first.to_s}#{to_string rest.car, rest.cdr}"
+    end
+  end
+
+  def invoke vm, args
+    vm.push_arg Nydp::StringAtom.new to_string(args.car, args.cdr)
+  end
+end

data/lib/nydp/builtin/type_of.rb

@@ -0,0 +1,11 @@
+class Nydp::Builtin::TypeOf
+  def initialize ns
+    @ns = ns
+  end
+
+  def invoke vm, args
+    arg = args.car
+    type = Nydp::Symbol.mk(arg.nydp_type.to_sym, @ns) if arg.respond_to?(:nydp_type)
+    vm.push_arg(type || Nydp.NIL)
+  end
+end

data/lib/nydp/core.rb

@@ -0,0 +1,66 @@
+require 'nydp'
+
+module Nydp
+  class Core
+    def name ; "Nydp Core" ; end
+
+    def relative_path name
+      File.join File.expand_path(File.dirname(__FILE__)), name
+    end
+
+    def load_rake_tasks
+      load relative_path '../tasks/tests.rake'
+    end
+
+    def loadfiles
+      b = relative_path('../lisp/boot.nydp')
+      t = relative_path('../lisp/test-runner.nydp')
+      [b,t]
+    end
+
+    def testfiles
+      Dir.glob(relative_path '../lisp/tests/**/*.nydp')
+    end
+
+    def setup ns
+      Symbol.mk(:cons,  ns).assign(Nydp::Builtin::Cons.new)
+      Symbol.mk(:car,   ns).assign(Nydp::Builtin::Car.new)
+      Symbol.mk(:cdr,   ns).assign(Nydp::Builtin::Cdr.new)
+      Symbol.mk(:+,     ns).assign(Nydp::Builtin::Plus.new)
+      Symbol.mk(:-,     ns).assign(Nydp::Builtin::Minus.new)
+      Symbol.mk(:*,     ns).assign(Nydp::Builtin::Times.new)
+      Symbol.mk(:/,     ns).assign(Nydp::Builtin::Divide.new)
+      Symbol.mk(:>,     ns).assign(Nydp::Builtin::GreaterThan.new)
+      Symbol.mk(:<,     ns).assign(Nydp::Builtin::LessThan.new)
+      Symbol.mk(:eval,  ns).assign(Nydp::Builtin::Eval.new(ns))
+      Symbol.mk(:hash,  ns).assign(Nydp::Builtin::Hash.new)
+      Symbol.mk(:apply, ns).assign(Nydp::Builtin::Apply.new)
+      Symbol.mk(:error, ns).assign(Nydp::Builtin::Error.new)
+      Symbol.mk(:quit,  ns).assign(Nydp::Builtin::Quit.new)
+      Symbol.mk(:p,     ns).assign(Nydp::Builtin::Puts.new)
+      Symbol.mk(:PI,    ns).assign Literal.new(3.1415)
+      Symbol.mk(:nil,   ns).assign Nydp.NIL
+      Symbol.mk(:t,     ns).assign Nydp.T
+      Symbol.mk(:sym,   ns).assign Nydp::Builtin::ToSym.new(ns)
+      Symbol.mk(:inspect,       ns).assign(Nydp::Builtin::Inspect.new)
+      Symbol.mk(:comment,       ns).assign(Nydp::Builtin::Comment.new)
+      Symbol.mk(:millisecs,     ns).assign(Nydp::Builtin::Millisecs.new)
+      Symbol.mk("random-string",ns).assign(Nydp::Builtin::RandomString.new)
+      Symbol.mk("to-string",    ns).assign(Nydp::Builtin::ToString.new)
+      Symbol.mk("string-pieces",ns).assign(Nydp::Builtin::StringPieces.new)
+      Symbol.mk("string-replace", ns).assign(Nydp::Builtin::StringReplace.new)
+      Symbol.mk("string-split"  , ns).assign(Nydp::Builtin::StringSplit.new  )
+      Symbol.mk("type-of",      ns).assign(Nydp::Builtin::TypeOf.new(ns))
+      Symbol.mk(:"eq?",         ns).assign(Nydp::Builtin::IsEqual.new)
+      Symbol.mk(:"pair?",       ns).assign(Nydp::Builtin::IsPair.new)
+      Symbol.mk(:"cdr-set",     ns).assign(Nydp::Builtin::CdrSet.new)
+      Symbol.mk(:"hash-get",    ns).assign(Nydp::Builtin::HashGet.new)
+      Symbol.mk(:"hash-set",    ns).assign(Nydp::Builtin::HashSet.new)
+      Symbol.mk(:"hash-keys",   ns).assign(Nydp::Builtin::HashKeys.new)
+      Symbol.mk(:"vm-info",     ns).assign Nydp::Builtin::VmInfo.new
+      Symbol.mk(:"pre-compile", ns).assign Nydp::Builtin::PreCompile.new
+    end
+  end
+end
+
+Nydp.plug_in Nydp::Core.new