nydp 0.4.5 → 0.4.6

data/lib/lisp/tests/multi-assign-examples.nydp

@@ -0,0 +1,6 @@
+(examples-for ampersand-syntax
+  ("assigns multiple values at once ; value of expr is last assigned value"
+   (with (a 1 b { foo 2 } c { d { e 3 } })
+         (let res (= a 10 b.foo 20 (&d.e c) 30)
+           (list a b.foo c.d.e res)))
+   (10 20 30 30)))

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

@@ -1,3 +1,6 @@
+(def-setting "testing.reset.string" "hello world")
+(def-setting "testing.reset.fn"     to-string)
+
 (examples-for settings/fn
   ("returns arg if it is a sym"
    (settings/fn 'foobar)
@@ -22,3 +25,16 @@
   ("wraps arg in a fn expression if it is a complex expression"
    (settings/fn '(let foo this that (rfnwith (complex stuff) (%td.tricky#syntax))))
    (fn (_) (let foo this that (rfnwith (complex stuff) ((percent-syntax || (dot-syntax td tricky#syntax))))))))
+
+(examples-for reset-setting
+  ("restores a setting to its original value"
+   (do (set-setting "testing.reset.string" "goodbye, dear life")
+       (reset-setting "testing.reset.string")
+       (setting "testing.reset.string"))
+   "hello world")
+
+  ("restores a setting to its original function value"
+   (do (set-setting "testing.reset.fn" "goodbye, dear life")
+       (reset-setting "testing.reset.fn")
+       (setting "testing.reset.fn"))
+   "testing.reset.fn"))

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

@@ -138,4 +138,7 @@ and args (\"world\" 36 6)"
 (examples-for string-strip
   ("removes leading whitespace"               (string-strip "    hello!")  "hello!" )
   ("removes trailing whitespace"              (string-strip "(world)   ") "(world)" )
-  ("removes leading and trailing whitespace"  (string-strip "\n\nme\n\n") "me"      ))
+  ("removes leading and trailing whitespace"  (string-strip "\n\nme\n\n") "me"      )
+  ("ignores leading and trailing whitespace for intenal lines"
+   (string-strip "\n\n  me  \n\n  you  \n\n\t them \t\n\n")
+   "me  \n\n  you  \n\n\t them"      ))

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
 

data/lib/nydp/builtin/date.rb

@@ -16,7 +16,12 @@ class Nydp::Builtin::Date
 
   # 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/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/ruby_wrap.rb

@@ -15,7 +15,8 @@ class Nydp::Builtin::RubyWrap
       when 2 ; ", a0, a1"
       when 3 ; ", a0, a1, a2"
       when 4 ; ", a0, a1, a2, a3"
-      else   ; raise "maximum 4 arguments!"
+      when 5 ; ", a0, a1, a2, a3, a4"
+      else   ; raise "maximum 5 arguments!"
       end
     end
 
@@ -24,7 +25,8 @@ class Nydp::Builtin::RubyWrap
                        gsub(/a0/, "args.car").
                        gsub(/a1/, "args.cdr.car").
                        gsub(/a2/, "args.cdr.cdr.car").
-                       gsub(/a3/, "args.cdr.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}
@@ -63,7 +65,8 @@ CODE
   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(: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

@@ -2,6 +2,6 @@ class Nydp::Builtin::StringPadLeft
   include Nydp::Builtin::Base, Singleton
 
   def builtin_invoke_4 vm, str, len, padding
-    vm.push_arg Nydp::StringAtom.new str.to_s.rjust len, padding.to_s
+    vm.push_arg str.to_s.rjust(len, padding.to_s)
   end
 end

data/lib/nydp/builtin/string_pad_right.rb

@@ -2,6 +2,6 @@ class Nydp::Builtin::StringPadRight
   include Nydp::Builtin::Base, Singleton
 
   def builtin_invoke_4 vm, str, len, padding
-    vm.push_arg Nydp::StringAtom.new str.to_s.ljust len, padding.to_s
+    vm.push_arg str.to_s.ljust(len, padding.to_s)
   end
 end

data/lib/nydp/builtin/string_replace.rb

@@ -7,6 +7,6 @@ class Nydp::Builtin::StringReplace
     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

@@ -5,8 +5,7 @@ class Nydp::Builtin::StringSplit
     target    = args.car.to_s
     separator = args.cdr.car.to_s
     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

data/lib/nydp/core.rb

@@ -26,8 +26,9 @@ module Nydp
 
     def setup ns
       Symbol.mk(:cons         , ns).assign(Nydp::Builtin::RubyWrap::Cons.instance)
-      Symbol.mk(:car          , ns).assign(Nydp::Builtin::RubyWrap::Car.instance)
-      Symbol.mk(:cdr          , ns).assign(Nydp::Builtin::RubyWrap::Cdr.instance)
+      Symbol.mk(:car          , ns).assign(Nydp::Builtin::RubyWrap::Car.instance )
+      Symbol.mk(:cdr          , ns).assign(Nydp::Builtin::RubyWrap::Cdr.instance )
+      Symbol.mk(:log          , ns).assign(Nydp::Builtin::RubyWrap::Log.instance )
 
       Symbol.mk(:+,     ns).assign(Nydp::Builtin::Plus.instance)
       Symbol.mk(:-,     ns).assign(Nydp::Builtin::Minus.instance)
@@ -59,6 +60,7 @@ module Nydp
       Symbol.mk("parse-in-string"  , ns).assign(Nydp::Builtin::ParseInString.instance)
       Symbol.mk("random-string"    , ns).assign(Nydp::Builtin::RandomString.instance)
       Symbol.mk("to-string"        , ns).assign(Nydp::Builtin::ToString.instance)
+      Symbol.mk("to-integer"       , ns).assign(Nydp::Builtin::ToInteger.instance)
       Symbol.mk("string-length"    , ns).assign(Nydp::Builtin::StringLength.instance)
       Symbol.mk("string-replace"   , ns).assign(Nydp::Builtin::StringReplace.instance)
       Symbol.mk("string-match"     , ns).assign(Nydp::Builtin::StringMatch.instance)

data/lib/nydp/core_ext.rb

@@ -6,6 +6,15 @@ class Object
   def lexical_reach n ; n    ; end
 end
 
+class Method
+  include Nydp::Converter
+  def invoke_1 vm             ; vm.push_arg call._nydp_wrapper                            ; end
+  def invoke_2 vm, a0         ; vm.push_arg call(n2r(a0))._nydp_wrapper                   ; end
+  def invoke_3 vm, a0, a1     ; vm.push_arg call(n2r(a0), n2r(a1))._nydp_wrapper          ; end
+  def invoke_4 vm, a0, a1, a2 ; vm.push_arg call(n2r(a0), n2r(a1), n2r(a2))._nydp_wrapper ; end
+  def invoke   vm, args       ; vm.push_arg call(*(args.map { |a| n2r a}))._nydp_wrapper  ; end
+end
+
 class NilClass
   def _nydp_wrapper ; Nydp::NIL ; end
 end
@@ -31,7 +40,10 @@ class ::Array
 end
 
 class ::String
-  def _nydp_wrapper ; Nydp::StringAtom.new self ; end
+  # def _nydp_wrapper  ; Nydp::StringAtom.new self  ; end
+  def as_method_name ; self.gsub(/-/, '_').to_sym ; end
+  def nydp_type      ; :string                    ; end
+  def to_ruby        ; self                       ; end
 end
 
 class ::Hash

data/lib/nydp/date.rb

@@ -18,6 +18,7 @@ module Nydp
 
     def initialize ruby_date ; @ruby_date = ruby_date ; end
 
+    def to_date   ; ruby_date                                        ; end
     def to_s      ; ruby_date.to_s                                   ; end
     def to_ruby   ; ruby_date                                        ; end
     def inspect   ; ruby_date.inspect                                ; end

data/lib/nydp/helper.rb

@@ -1,17 +1,39 @@
 module Nydp
   module AutoWrap
     # include this and be sure to either override #_nydp_ok? or #_nydp_whitelist
-    # #_nydp_whitelist should return a list of methods which are safe for nydp to invoke
-    def _nydp_wrapper                 ; self                                            ; end
-    def _nydp_ok?              method ; _nydp_whitelist.include? method                 ; end
-    def _nydp_safe_send method, *args ; send method, *args if _nydp_ok? method          ; end
-    def _nydp_get                 key ; _nydp_safe_send(key.to_s.as_method_name)        ; end
-    def to_ruby                       ; self                                            ; end
+    # #_nydp_whitelist should return a list of accessor (zero-arg) methods which are safe for nydp to invoke
+    # #_nydp_procify should return a list of methods that can be exposed to script code.
+    #
+    # class Blub
+    #   _nydp_procs << :blubme
+    #   def blubme where, when
+    #     puts "blubme #{where}, #{when}"
+    #   end
+    # end
+    #
+    # in nydp, if blub is an instance of Blub:
+    #
+    # (blub.blubme "here" "now")
+    #
+    # prints
+    #
+    # blubme here, now
+    #
+    def _nydp_wrapper                 ; self                                     ; end
+    def _nydp_ok?              method ; _nydp_whitelist.include? method          ; end
+    def _nydp_procify?         method ; _nydp_procs.include? method              ; end # override to allow returning Method instances for given method name
+    def _nydp_get                 key ; _nydp_safe_send(key.to_s.as_method_name) ; end
+    def to_ruby                       ; self                                     ; end
+    def _nydp_safe_send meth, *args
+      return send meth, *args if _nydp_ok?(meth)
+      return method(meth)     if _nydp_procify?(meth)
+    end
   end
 
   class Struct < ::Struct
     include AutoWrap
     def _nydp_whitelist ; members ; end
+    def _nydp_procs     ; []      ; end
   end
 
   module Converter
@@ -61,7 +83,7 @@ module Nydp
 
     def literal? expr
       case expr
-      when String, Float, Integer, Fixnum, Nydp::Symbol, Nydp::StringAtom, Nydp::Truth, Nydp::Nil
+      when String, Float, Integer, Fixnum, Nydp::Symbol, Nydp::Truth, Nydp::Nil
         true
       else
         false

data/lib/nydp/pair.rb

@@ -39,9 +39,14 @@ class Nydp::Pair
   end
 
   # returns Array of elements after calling #n2r on each element
-  def to_ruby list=[]
-    list << n2r(car)
-    cdr.is_a?(Nydp::Pair) ? cdr.to_ruby(list) : list
+  def to_ruby list=[], pair=self
+    list << n2r(pair.car)
+    while(pair.cdr.is_a?(Nydp::Pair))
+      pair = pair.cdr
+      list << n2r(pair.car)
+    end
+
+    list
   end
 
   # returns Array of elements as they are

data/lib/nydp/parser.rb

@@ -34,8 +34,7 @@ module Nydp
       when /^(.*),@$/
         prefix_list $1, Pair.from_list([sym(:"unquote-splicing"), list])
       else
-        pfx = Nydp::StringAtom.new prefix
-        Pair.from_list([sym(:"prefix-list"), pfx, list])
+        Pair.from_list([sym(:"prefix-list"), prefix, list])
       end
     end
 
@@ -111,7 +110,7 @@ module Nydp
       when :symbol
         parse_symbol token.last
       when :comment
-        Pair.from_list [sym(:comment), Nydp::StringAtom.new(token.last)]
+        Pair.from_list [sym(:comment), token.last]
       else
         token.last
       end
@@ -132,11 +131,11 @@ module Nydp
       fragments = [sym(:"string-pieces")]
       string_token = token_stream.next_string_fragment(open_delimiter, close_delimiter, INTERPOLATION_SIGN, INTERPOLATION_ESCAPES)
       raise "unterminated string" if string_token.nil?
-      fragments << Nydp::StringAtom.new(string_token.string)
+      fragments << string_token.string
       while !(string_token.is_a? StringFragmentCloseToken)
         fragments << expression(token_stream)
         string_token = token_stream.next_string_fragment('', close_delimiter, INTERPOLATION_SIGN, INTERPOLATION_ESCAPES)
-        fragments << Nydp::StringAtom.new(string_token.string)
+        fragments << string_token.string
       end
 
       if fragments.size == 2

data/lib/nydp/truth.rb

@@ -19,8 +19,8 @@ module Nydp
     def car         ; self          ; end
     def cdr         ; self          ; end
     def size        ; 0             ; end
-    def is?   other ; self == other ; end
-    def isnt? other ; self != other ; end
+    def is?   other ; self.equal? other  ; end
+    def isnt? other ; !self.equal? other ; end
     def to_s        ; ""            ; end
     def + other     ; other         ; end
     def copy        ; self          ; end