nydp 0.4.2 → 0.5.1

data/lib/lisp/tests/syntax-tests.nydp

@@ -10,7 +10,11 @@
   ("dislikes no-prefix"
    (on-err (joinstr "\n" errors)
            (pre-compile '(:foo 1 2 3)))
-   "\"Irregular ': syntax: got (|| foo) : not prefix-syntax : in :foo\""))
+   "expanding
+(colon-syntax || foo)
+with
+(fn names ((orf (hash-get colon-syntax-overrides car [0#0#0]names) default-colon-syntax) [0#0#0]names))
+Irregular ': syntax: got (|| foo) : not prefix-syntax : in :foo"))
 
 (examples-for prefix-list
   ("one argument"

data/lib/lisp/tests/to-integer-examples.nydp

@@ -0,0 +1,16 @@
+(examples-for to-integer
+  ("converts a string"
+   (to-integer "1234")
+   1234)
+
+  ("converts a date"
+   (to-integer (date 2004 3 12))
+   1079046000)
+
+  ("converts a time"
+   (to-integer (time 2004 3 12 18 45))
+   1079113500)
+
+  ("returns nonsense for non-integer"
+   (to-integer { foo 'bar })
+   0))

data/lib/lisp/tests/validation-examples.nydp

@@ -0,0 +1,15 @@
+(validate/def string test-0 (if (< (len string)  6) (mf "length" "should be more than 6")))
+(validate/def string test-0 (if (> (len string) 10) (mf "length" "should be less than 10")))
+
+(examples-for validate
+  ("returns a message about a string being too short"
+   (to-string:validate "foo" 'test-0)
+   "{\"length\"=>(\"should be more than 6\")}")
+
+("returns a message about a string being too long"
+   (to-string:validate "foo bar toto titi" 'test-0)
+   "{\"length\"=>(\"should be less than 10\")}")
+
+("returns an empty hash"
+   (to-string:validate "foo bar" 'test-0)
+   "{}"))

data/lib/nydp.rb

@@ -2,6 +2,10 @@ require 'date'
 require 'set'
 
 module Nydp
+  class << self
+    attr_accessor :logger # not used by this gem but very useful in your app
+  end
+
   class Namespace < Hash
   end
 
@@ -11,6 +15,9 @@ module Nydp
     function = Symbol.mk(function_name.to_sym, ns).value
     function.invoke vm, r2n(args)
     vm.thread
+  rescue StandardError => e
+    friendly_args = args.map { |a| a.respond_to?(:_nydp_compact_inspect) ? a._nydp_compact_inspect : a }
+    raise Nydp::Error.new("Invoking #{function_name}\nwith args #{friendly_args.inspect}")
   end
 
   def self.reader                          txt ; Nydp::StringReader.new txt                                 ; end
@@ -48,9 +55,9 @@ module Nydp
 
   def self.repl options={ }
     toplevel do
-      silent = options.delete :silent
-      ns     = options.delete :ns
-      launch_time = Time.now
+      launch_time      = Time.now
+      silent           = options.delete :silent
+      ns               = options.delete :ns
       last_script_time = Time.now
       puts "welcome to nydp #{options.inspect}" unless silent
       reader = Nydp::ReadlineReader.new $stdin, "nydp > "

data/lib/nydp/assignment.rb

@@ -8,6 +8,8 @@ module Nydp
 
     def execute vm
       @name.assign vm.peek_arg, vm.current_context
+    rescue
+      raise "assigning #{@name.inspect}"
     end
 
     def to_s
@@ -26,9 +28,12 @@ module Nydp
     end
 
     def initialize name, value, value_src
-      @value_src = value_src
-      n = AssignmentInstruction.new name
-      @instructions = cons(value, cons(n))
+      @name, @value, @value_src = name, value, value_src
+      @instructions = cons(value, cons(AssignmentInstruction.new(name)))
+    end
+
+    def lexical_reach n
+      [@name.lexical_reach(n), @value.lexical_reach(n)].max
     end
 
     def to_s
@@ -39,6 +44,8 @@ module Nydp
 
     def execute vm
       vm.push_ctx_instructions @instructions
+    rescue
+      raise "assigning #{@value.inspect} to #{@name.inspect}"
     end
   end
 end

data/lib/nydp/builtin.rb

@@ -32,13 +32,13 @@ module Nydp::Builtin
       handle_error e, arg_0, arg_1, arg_2
     end
 
+    # called from 'apply (among others)
     def invoke vm, args
       builtin_invoke vm, args
     rescue StandardError => e
       handle_error e, *(args.to_a)
     end
 
-
     def handle_error e, *args
       case e
       when Nydp::Error

data/lib/nydp/builtin/abs.rb

@@ -0,0 +1,8 @@
+class Nydp::Builtin::Abs
+  include Nydp::Builtin::Base, Singleton
+
+  def invoke_2         vm, a0 ; vm.push_arg(a0.abs)   ; end
+  def builtin_invoke vm, args ; invoke_2 vm, args.car ; end
+
+  def name ; "mod" ; end
+end

data/lib/nydp/builtin/date.rb

@@ -1,13 +1,27 @@
 class Nydp::Builtin::Date
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
 
+  def builtin_invoke vm, args
+    case args.size
+    when 0 ; builtin_invoke_1 vm
+    when 1 ; builtin_invoke_2 vm, args.car
+    when 2 ; builtin_invoke_3 vm, args.car, args.cdr.car
+    when 3 ; builtin_invoke_4 vm, args.car, args.cdr.car, args.cdr.cdr.car
+    end
+  end
+
   def builtin_invoke_1 vm
     vm.push_arg(Nydp::Date.new Date.today)
   end
 
   # it's a Time object (or any object that responds to #to_date)
   def builtin_invoke_2 vm, arg
-    vm.push_arg(Nydp::Date.new arg.to_date)
+    arg = if arg.respond_to?(:to_date)
+            arg.to_date
+          elsif arg.is_a?(String)
+            ::Date.parse(arg)
+          end
+    vm.push_arg(Nydp::Date.new arg)
   end
 
   def builtin_invoke_3 vm, a0, a1

data/lib/nydp/builtin/error.rb

@@ -4,6 +4,6 @@ class Nydp::Builtin::Error
   # override #invoke on nydp/builtin/base because
   # we don't want to inherit error handling
   def builtin_invoke vm, args
-    raise Nydp::Error.new(args.to_a.map(&:inspect).join("\n"), vm.last_error)
+    raise Nydp::Error.new(args.to_a.map(&:to_s).join("\n"), vm.last_error)
   end
 end

data/lib/nydp/builtin/hash.rb

@@ -2,8 +2,18 @@ require "nydp/hash"
 
 class Nydp::Builtin::Hash
   include Nydp::Helper, Nydp::Builtin::Base, Singleton
+
   def builtin_invoke vm, args
-    vm.push_arg(Nydp::Hash.new)
+    vm.push_arg(build_hash Nydp::Hash.new, args)
+  end
+
+  def build_hash h, args
+    return h if Nydp::NIL.is? args
+    k = args.car
+    rest = args.cdr
+    v = rest.car
+    h[k] = v
+    build_hash h, rest.cdr
   end
 end
 
@@ -56,3 +66,16 @@ class Nydp::Builtin::HashMerge
     vm.push_arg hash_0.merge hash_1
   end
 end
+
+class Nydp::Builtin::HashSlice
+  include Nydp::Helper, Nydp::Builtin::Base, Singleton
+
+  def builtin_invoke vm, args
+    old   = args.car
+    h     = old.class.new
+    slice = args.cdr.car
+    slice = slice.map { |k| n2r k } unless old.is_a? Nydp::Hash
+    slice.each { |k| h[k] = old[k] if old.key?(k) }
+    vm.push_arg h
+  end
+end

data/lib/nydp/builtin/inspect.rb

@@ -2,6 +2,6 @@ class Nydp::Builtin::Inspect
   include Nydp::Builtin::Base, Singleton
 
   def builtin_invoke vm, args
-    vm.push_arg Nydp::StringAtom.new(args.car.inspect)
+    vm.push_arg args.car.inspect
   end
 end

data/lib/nydp/builtin/plus.rb

@@ -10,13 +10,21 @@ class Nydp::Builtin::Plus
     vm.push_arg case args.car
                 when Nydp::Pair
                   sum(args, Nydp::NIL)
-                when String, Nydp::StringAtom
-                  sum(args, Nydp::StringAtom.new(""))
+                when String
+                  string_concat("", args)
                 else
                   sum(args.cdr, args.car)
                 end
   end
 
+  def string_concat init, others
+    while others && !Nydp::NIL.is?(others)
+      init << others.car.to_s
+      others = others.cdr
+    end
+    init
+  end
+
   def sum args, accum
     while args && !Nydp::NIL.is?(args)
       accum += args.car

data/lib/nydp/builtin/random_string.rb

@@ -5,7 +5,7 @@ class Nydp::Builtin::RandomString
 
   def builtin_invoke vm, args
     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
+    s = (0...(length || 10)).inject("") {|a,i| a << RANDOM_CHARS[rand(RANDOM_CHARS.size)] }
+    vm.push_arg s
   end
 end

data/lib/nydp/builtin/{car.rb → regexp.rb}

@@ -1,7 +1,7 @@
-class Nydp::Builtin::Car
+class Nydp::Builtin::Regexp
   include Nydp::Builtin::Base, Singleton
 
   def builtin_invoke vm, args
-    vm.push_arg args.car.car
+    vm.push_arg Regexp.compile(args.car.to_s)
   end
 end

data/lib/nydp/builtin/ruby_wrap.rb

@@ -0,0 +1,72 @@
+class Nydp::Builtin::RubyWrap
+  @@builtins           = { }
+
+  def self.builtins
+    @@builtins
+  end
+
+  class Coder < Struct.new(:name, :size, :code, :helpers)
+    def msize ; size + 1 ; end
+
+    def arg_mapper
+      case size
+      when 0 ; ""
+      when 1 ; ", a0"
+      when 2 ; ", a0, a1"
+      when 3 ; ", a0, a1, a2"
+      when 4 ; ", a0, a1, a2, a3"
+      when 5 ; ", a0, a1, a2, a3, a4"
+      else   ; raise "maximum 5 arguments!"
+      end
+    end
+
+    def to_ruby
+      generic_code = code.
+                       gsub(/a0/, "args.car").
+                       gsub(/a1/, "args.cdr.car").
+                       gsub(/a2/, "args.cdr.cdr.car").
+                       gsub(/a3/, "args.cdr.cdr.cdr.car").
+                       gsub(/a4/, "args.cdr.cdr.cdr.cdr.car")
+      <<CODE
+class #{name}
+  include Nydp::Builtin::Base, Singleton#{helpers}
+
+  def builtin_invoke_#{msize} vm#{ arg_mapper }
+    vm.push_arg(#{code})
+  end
+
+  def builtin_invoke vm, args
+    vm.push_arg(#{generic_code})
+  end
+end
+CODE
+    end
+  end
+
+  def self.const_missing const
+    coder = @@builtins[const]
+    coder ? class_eval(coder.to_ruby) : super
+    const_get const
+  end
+
+  class WrapperBuilder
+    def initialize default_helpers
+      @default_helpers = default_helpers.to_s.strip != "" ? ", #{default_helpers}" : ""
+    end
+
+    def build name, args, code, helpers=""
+      extra_helpers = helpers.to_s.strip != "" ? ", #{helpers}" : ""
+      Nydp::Builtin::RubyWrap.builtins[name.to_sym] = Coder.new(name.to_sym, args, code, "#{@default_helpers}#{extra_helpers}")
+    end
+  end
+
+  def self.builder includes
+    WrapperBuilder.new(includes)
+  end
+
+  core_builder = builder ""
+  core_builder.build(:Cons, 2, %{ Nydp::Pair.new(a0, a1) }        )
+  core_builder.build(:Car , 1, %{ a0.car }                        )
+  core_builder.build(:Cdr , 1, %{ a0.cdr }                        )
+  core_builder.build(:Log , 1, %{ r2n Nydp.logger.info(a0.to_s) } )
+end

data/lib/nydp/builtin/string_match.rb

@@ -10,8 +10,8 @@ class Nydp::Builtin::StringMatch
 
     if match
       result             = Nydp::Hash.new
-      result[kmatch]     = Nydp::StringAtom.new match.to_s
-      result[kcaptures]  = Nydp::Pair.from_list match.captures.map { |cap| Nydp::StringAtom.new cap.to_s }
+      result[kmatch]     = match.to_s
+      result[kcaptures]  = Nydp::Pair.from_list match.captures.map { |cap| cap.to_s }
     else
       result             = Nydp::NIL
     end

data/lib/nydp/builtin/string_pad_left.rb

@@ -0,0 +1,7 @@
+class Nydp::Builtin::StringPadLeft
+  include Nydp::Builtin::Base, Singleton
+
+  def builtin_invoke_4 vm, str, len, padding
+    vm.push_arg str.to_s.rjust(len, padding.to_s)
+  end
+end

data/lib/nydp/builtin/string_pad_right.rb

@@ -0,0 +1,7 @@
+class Nydp::Builtin::StringPadRight
+  include Nydp::Builtin::Base, Singleton
+
+  def builtin_invoke_4 vm, str, len, padding
+    vm.push_arg str.to_s.ljust(len, padding.to_s)
+  end
+end

data/lib/nydp/builtin/string_replace.rb

@@ -2,11 +2,11 @@ class Nydp::Builtin::StringReplace
   include Nydp::Builtin::Base, Singleton
 
   def builtin_invoke vm, args
-    to_remove = Regexp.new args.car.to_s
-    to_insert = args.cdr.car.to_s
+    to_remove = Regexp.new args.car.to_ruby
+    to_insert = args.cdr.car.to_ruby
     target    = args.cdr.cdr.car.to_s
     result    = target.to_s.gsub to_remove, to_insert
 
-    vm.push_arg Nydp::StringAtom.new result
+    vm.push_arg result
   end
 end

data/lib/nydp/builtin/string_split.rb

@@ -3,10 +3,11 @@ class Nydp::Builtin::StringSplit
 
   def builtin_invoke vm, args
     target    = args.car.to_s
-    separator = args.cdr.car.to_s
+    separator = args.cdr.car
+    separator = separator.to_s unless separator.is_a? Regexp
+
     result    = target.split separator, -1
-    list      = result.map { |s| Nydp::StringAtom.new s }
 
-    vm.push_arg Nydp::Pair.from_list list
+    vm.push_arg Nydp::Pair.from_list result
   end
 end

data/lib/nydp/builtin/to_integer.rb

@@ -0,0 +1,23 @@
+module Nydp::Builtin
+  class ToInteger
+    include Nydp::Builtin::Base, Singleton
+
+    def builtin_invoke_2 vm, arg
+      arg = n2r arg
+
+      i = if arg.respond_to? :to_i
+            arg.to_i
+          elsif arg.respond_to? :to_time
+            arg.to_time.to_i
+          else
+            arg.to_s.to_i
+          end
+
+      vm.push_arg r2n i
+    end
+
+    def builtin_invoke vm, args
+      builtin_invoke_2 vm, args.car
+    end
+  end
+end

data/lib/nydp/builtin/to_string.rb

@@ -3,14 +3,7 @@ module Nydp::Builtin
     include Nydp::Builtin::Base, Singleton
 
     def builtin_invoke vm, args
-      arg = args.car
-      val = case arg.class
-            when Nydp::StringAtom
-              arg
-            else
-              Nydp::StringAtom.new arg.to_s
-            end
-      vm.push_arg val
+      vm.push_arg args.car.to_s
     end
   end
 
@@ -20,7 +13,7 @@ module Nydp::Builtin
     def builtin_invoke vm, args
       arg = args.car
       val = case arg
-            when Nydp::StringAtom
+            when String
               arg.length
             else
               0