nydp 0.5.0 → 0.6.0

data/lib/nydp/core.rb

@@ -2,11 +2,9 @@ require 'nydp/plugin'
 
 module Nydp
   class Core
-    def name ; "Nydp Core" ; end
+    include Nydp::PluginHelper
 
-    def relative_path name
-      File.join File.expand_path(File.dirname(__FILE__)), name
-    end
+    def name ; "Nydp Core" ; end
 
     def base_path
       relative_path "../lisp/"
@@ -17,81 +15,84 @@ module Nydp
     end
 
     def loadfiles
-      Dir.glob(relative_path '../lisp/core-*.nydp').sort
+      file_readers Dir.glob(relative_path '../lisp/core-*.nydp').sort
     end
 
     def testfiles
-      Dir.glob(relative_path '../lisp/tests/**/*.nydp')
+      file_readers Dir.glob(relative_path '../lisp/tests/**/*.nydp')
     end
 
     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(:log          , ns).assign(Nydp::Builtin::RubyWrap::Log.instance )
-
-      Symbol.mk(:+,     ns).assign(Nydp::Builtin::Plus.instance)
-      Symbol.mk(:-,     ns).assign(Nydp::Builtin::Minus.instance)
-      Symbol.mk(:*,     ns).assign(Nydp::Builtin::Times.instance)
-      Symbol.mk(:/,     ns).assign(Nydp::Builtin::Divide.instance)
-      Symbol.mk(:>,     ns).assign(Nydp::Builtin::GreaterThan.instance)
-      Symbol.mk(:<,     ns).assign(Nydp::Builtin::LessThan.instance)
-      Symbol.mk(:mod,   ns).assign(Nydp::Builtin::Modulo.instance)
-      Symbol.mk(:eval,  ns).assign(Nydp::Builtin::Eval.instance)
-      Symbol.mk(:false, ns).assign(false)
-      Symbol.mk(:hash,  ns).assign(Nydp::Builtin::Hash.instance)
-      Symbol.mk(:apply, ns).assign(Nydp::Builtin::Apply.instance)
-      Symbol.mk(:date,  ns).assign(Nydp::Builtin::Date.instance)
-      Symbol.mk(:error, ns).assign(Nydp::Builtin::Error.instance)
-      Symbol.mk(:parse, ns).assign(Nydp::Builtin::Parse.instance)
-      Symbol.mk(:p,     ns).assign(Nydp::Builtin::Puts.instance)
-      Symbol.mk(:PI,    ns).assign 3.1415
-      Symbol.mk(:nil,   ns).assign Nydp::NIL
-      Symbol.mk(:rand,  ns).assign Nydp::Builtin::Rand.instance
-      Symbol.mk(:sort,  ns).assign Nydp::Builtin::Sort.instance
-      Symbol.mk(:abs,   ns).assign Nydp::Builtin::Abs.instance
-      Symbol.mk(:sqrt,  ns).assign Nydp::Builtin::Sqrt.instance
-      Symbol.mk(:t,     ns).assign Nydp::T
-      Symbol.mk(:sym,   ns).assign Nydp::Builtin::Sym.instance
-      Symbol.mk(:ensuring          , ns).assign(Nydp::Builtin::Ensuring.instance)
-      Symbol.mk(:inspect           , ns).assign(Nydp::Builtin::Inspect.instance)
-      Symbol.mk(:comment           , ns).assign(Nydp::Builtin::Comment.instance)
-      Symbol.mk("handle-error"     , ns).assign(Nydp::Builtin::HandleError.instance)
-      Symbol.mk("parse-in-string"  , ns).assign(Nydp::Builtin::ParseInString.instance)
-      Symbol.mk("random-string"    , ns).assign(Nydp::Builtin::RandomString.instance)
-      Symbol.mk("regexp"           , ns).assign(Nydp::Builtin::Regexp.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)
-      Symbol.mk("string-split"     , ns).assign(Nydp::Builtin::StringSplit.instance)
-      Symbol.mk("string/pad-left"  , ns).assign(Nydp::Builtin::StringPadLeft.instance)
-      Symbol.mk("string/pad-right" , ns).assign(Nydp::Builtin::StringPadRight.instance)
-      Symbol.mk("time"             , ns).assign(Nydp::Builtin::Time.instance)
-      Symbol.mk("thread-locals"    , ns).assign(Nydp::Builtin::ThreadLocals.instance)
-      Symbol.mk("type-of"          , ns).assign(Nydp::Builtin::TypeOf.instance)
-      Symbol.mk(:"eq?"             , ns).assign(Nydp::Builtin::IsEqual.instance)
-      Symbol.mk(:"cdr-set"         , ns).assign(Nydp::Builtin::CdrSet.instance)
-      Symbol.mk(:"hash-get"        , ns).assign(Nydp::Builtin::HashGet.instance)
-      Symbol.mk(:"hash-set"        , ns).assign(Nydp::Builtin::HashSet.instance)
-      Symbol.mk(:"hash-keys"       , ns).assign(Nydp::Builtin::HashKeys.instance)
-      Symbol.mk(:"hash-key?"       , ns).assign(Nydp::Builtin::HashKeyPresent.instance)
-      Symbol.mk(:"hash-merge"      , ns).assign(Nydp::Builtin::HashMerge.instance)
-      Symbol.mk(:"hash-slice"      , ns).assign(Nydp::Builtin::HashSlice.instance)
-      Symbol.mk(:"vm-info"         , ns).assign Nydp::Builtin::VmInfo.instance
-      Symbol.mk(:"pre-compile"     , ns).assign Nydp::Builtin::PreCompile.instance
-      Symbol.mk(:"script-run"      , ns).assign Nydp::Builtin::ScriptRun.instance
-      Symbol.mk(:"**"              , ns).assign Nydp::Builtin::MathPower.instance
-      Symbol.mk(:"⌊"               , ns).assign Nydp::Builtin::MathFloor.instance
-      Symbol.mk(:"math-floor"      , ns).assign Nydp::Builtin::MathFloor.instance
-      Symbol.mk(:"⌈"               , ns).assign Nydp::Builtin::MathCeiling.instance
-      Symbol.mk(:"math-ceiling"    , ns).assign Nydp::Builtin::MathCeiling.instance
-      Symbol.mk(:"math-round"      , ns).assign Nydp::Builtin::MathRound.instance
-      Symbol.mk(:"⋂"               , ns).assign Nydp::Builtin::SetIntersection.instance
-      Symbol.mk(:"set-intersection", ns).assign Nydp::Builtin::SetIntersection.instance
-      Symbol.mk(:"⋃"               , ns).assign Nydp::Builtin::SetUnion.instance
-      Symbol.mk(:"set-union"       , ns).assign Nydp::Builtin::SetUnion.instance
+      ns.assign(:cons              , Nydp::Builtin::RubyWrap::Cons.instance          )
+      ns.assign(:car               , Nydp::Builtin::RubyWrap::Car.instance           )
+      ns.assign(:cdr               , Nydp::Builtin::RubyWrap::Cdr.instance           )
+      ns.assign(:log               , Nydp::Builtin::Log.instance                     )
+      ns.assign(:ln                , Nydp::Builtin::RubyWrap::Ln.instance            )
+      ns.assign(:mod               , Nydp::Builtin::RubyWrap::Modulo.instance        )
+      ns.assign(:sqrt              , Nydp::Builtin::RubyWrap::Sqrt.instance          )
+      ns.assign(:regexp            , Nydp::Builtin::RubyWrap::Regexp.instance        )
+      ns.assign("string/pad-left"  , Nydp::Builtin::RubyWrap::StringPadLeft.instance )
+      ns.assign("string/pad-right" , Nydp::Builtin::RubyWrap::StringPadRight.instance)
+      ns.assign("string/force-encoding", Nydp::Builtin::RubyWrap::StringForceEncoding.instance)
+      ns.assign("to-list"          , Nydp::Builtin::RubyWrap::ToList.instance        )
+      ns.assign(:+                 , Nydp::Builtin::Plus.instance                    )
+      ns.assign(:-                 , Nydp::Builtin::Minus.instance                   )
+      ns.assign(:*                 , Nydp::Builtin::Times.instance                   )
+      ns.assign(:/                 , Nydp::Builtin::Divide.instance                  )
+      ns.assign(:>                 , Nydp::Builtin::GreaterThan.instance             )
+      ns.assign(:<                 , Nydp::Builtin::LessThan.instance                )
+      ns.assign(:eval              , Nydp::Builtin::Eval.new(ns)                     )
+      ns.assign(:false             , false                                           )
+      ns.assign(:hash              , Nydp::Builtin::Hash.instance                    )
+      ns.assign(:apply             , Nydp::Builtin::Apply.instance                   )
+      ns.assign(:date              , Nydp::Builtin::Date.instance                    )
+      ns.assign(:error             , Nydp::Builtin::Error.instance                   )
+      ns.assign(:parse             , Nydp::Builtin::Parse.instance                   )
+      ns.assign(:p                 , Nydp::Builtin::Puts.instance                    )
+      ns.assign(:PI                , Math::PI                                        )
+      ns.assign(:"π"               , Math::PI                                        )
+      ns.assign(:rand              , Nydp::Builtin::Rand.instance                    )
+      ns.assign(:rng               , Nydp::Builtin::RNG.instance                     )
+      ns.assign(:sort              , Nydp::Builtin::Sort.instance                    )
+      ns.assign(:abs               , Nydp::Builtin::Abs.instance                     )
+      ns.assign(:sym               , Nydp::Builtin::Sym.instance                     )
+      ns.assign(:ensuring          , Nydp::Builtin::Ensuring.instance                )
+      ns.assign(:inspect           , Nydp::Builtin::Inspect.instance                 )
+      ns.assign(:comment           , Nydp::Builtin::Comment.instance                 )
+      ns.assign("handle-error"     , Nydp::Builtin::HandleError.instance             )
+      ns.assign("parse-in-string"  , Nydp::Builtin::ParseInString.instance           )
+      ns.assign("random-string"    , Nydp::Builtin::RandomString.instance            )
+      ns.assign("to-string"        , Nydp::Builtin::ToString.instance                )
+      ns.assign("to-integer"       , Nydp::Builtin::ToInteger.instance               )
+      ns.assign("string-length"    , Nydp::Builtin::StringLength.instance            )
+      ns.assign("string-replace"   , Nydp::Builtin::StringReplace.instance           )
+      ns.assign("string-match"     , Nydp::Builtin::StringMatch.instance             )
+      ns.assign("string-split"     , Nydp::Builtin::StringSplit.instance             )
+      ns.assign("time"             , Nydp::Builtin::Time.instance                    )
+      ns.assign("thread-locals"    , Nydp::Builtin::ThreadLocals.instance            )
+      ns.assign("type-of"          , Nydp::Builtin::TypeOf.instance                  )
+      ns.assign(:"eq?"             , Nydp::Builtin::IsEqual.instance                 )
+      ns.assign(:"cdr-set"         , Nydp::Builtin::CdrSet.instance                  )
+      ns.assign(:"hash-get"        , Nydp::Builtin::HashGet.instance                 )
+      ns.assign(:"hash-set"        , Nydp::Builtin::HashSet.instance                 )
+      ns.assign(:"hash-keys"       , Nydp::Builtin::HashKeys.instance                )
+      ns.assign(:"hash-key?"       , Nydp::Builtin::HashKeyPresent.instance          )
+      ns.assign(:"hash-merge"      , Nydp::Builtin::HashMerge.instance               )
+      ns.assign(:"hash-slice"      , Nydp::Builtin::HashSlice.instance               )
+      ns.assign(:"hash-to-array"   , Nydp::Builtin::HashToArray.instance             )
+      ns.assign(:"vm-info"         , Nydp::Builtin::VmInfo.instance                  )
+      ns.assign(:"pre-compile-new-expression", Nydp::Builtin::PreCompile.instance    )
+      ns.assign(:"script-run"      , Nydp::Builtin::ScriptRun.instance               )
+      ns.assign(:"**"              , Nydp::Builtin::MathPower.instance               )
+      ns.assign(:"⌊"               , Nydp::Builtin::MathFloor.instance               )
+      ns.assign(:"math-floor"      , Nydp::Builtin::MathFloor.instance               )
+      ns.assign(:"⌈"               , Nydp::Builtin::MathCeiling.instance             )
+      ns.assign(:"math-ceiling"    , Nydp::Builtin::MathCeiling.instance             )
+      ns.assign(:"math-round"      , Nydp::Builtin::MathRound.instance               )
+      ns.assign(:"⋂"               , Nydp::Builtin::SetIntersection.instance         )
+      ns.assign(:"set-intersection", Nydp::Builtin::SetIntersection.instance         )
+      ns.assign(:"⋃"               , Nydp::Builtin::SetUnion.instance                )
+      ns.assign(:"set-union"       , Nydp::Builtin::SetUnion.instance                )
     end
   end
 end

data/lib/nydp/core_ext.rb

@@ -1,54 +1,118 @@
 class Object
-  def _nydp_get     a ; raise "_nydp_get : not gettable: #{a.inspect} on #{self.class.name}" ; end
-  def _nydp_set  a, v ; raise "_nydp_get : not settable: #{a.inspect} on #{self.class.name}" ; end
-  def _nydp_keys      ; []   ; end
-  def _nydp_wrapper   ; self ; end
-  def lexical_reach n ; n    ; end
+  def _nydp_get     a ; raise "_nydp_get : not gettable: #{a._nydp_inspect} on #{self.class.name}" ; end
+  def _nydp_set  a, v ; raise "_nydp_get : not settable: #{a._nydp_inspect} on #{self.class.name}" ; end
+  def _nydp_keys      ; []      ; end
+  def _nydp_wrapper         ; self          ; end
+  def _nydp_inspect         ; inspect       ; end
+  def _nydp_to_s            ; to_s          ; end
+  def _nydp_compact_inspect ; _nydp_inspect ; end
+  def lexical_reach       n ; n             ; end
+  def to_ruby               ; self          ; end
+  def compile_to_ruby indent, srcs, opts=nil ; "#{indent}#{inspect}" ; 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
+  def _nydp_call *args ; (call *(rubify args))._nydp_wrapper ; end
 end
 
-class NilClass
-  def _nydp_wrapper ; Nydp::NIL ; end
+class Proc
+  alias _nydp_call call
 end
 
-class FalseClass
-  def _nydp_wrapper ; Nydp::NIL ; end
+class TrueClass
+  def _nydp_inspect   ; 't'    ; end
+  def assign       *_ ; self   ; end
+  def nydp_type       ; :truth ; end
+  def _nydp_get     a ; self   ; end
+  def _nydp_set  a, v ; self   ; end
+  def _nydp_to_s      ; "t"    ; end
+  def compile_to_ruby indent, srcs, opts=nil ; "#{indent}true" ; end
 end
 
-class TrueClass
-  def _nydp_wrapper ; Nydp::T ; end
+class CantCallNil < NoMethodError
+end
+
+class NilClass
+  def car            ; self               ; end
+  def cdr            ; self               ; end
+  def size           ; 0                  ; end
+  def is?      other ; self.equal? other  ; end
+  def isnt?    other ; !self.equal? other ; end
+  def +        other ; other              ; end
+  def copy           ; self               ; end
+  def assign      *_ ; self               ; end
+  def nydp_type      ; :nil               ; end
+  def _nydp_get    a ; self               ; end
+  def _nydp_set a, v ; self               ; end
+  def &        other ; self               ; end
+  def |        other ; other              ; end
+  def _nydp_call  *_ ; raise CantCallNil  ; end
+  def compile_to_ruby i, s, o=nil ; "#{i}nil"      ; end
+end
+
+class FalseClass
+  def _nydp_wrapper ; nil ; end
 end
 
 class ::Symbol
-  def _nydp_wrapper ; Nydp::FrozenSymbol.mk(self) ; end
+  def _nydp_inspect
+    _ins = to_s
+    _nydp_untidy?(_ins) ? "|#{_ins.gsub(/\|/, '\|')}|" : _ins
+  end
+
+  def nydp_type  ; :symbol ; end
+  # def execute vm ; self    ; end
+
+  alias :inspect_before_nydp :inspect
+  def inspect
+    if self == :"#="
+      ':"#="'
+    else
+      inspect_before_nydp
+    end
+  end
+
+  private
+
+  def _nydp_untidy? s
+    (s == "") || (s == nil) || (s =~ /[\s\|,\(\)"]/)
+  end
 end
 
 class ::Date
-  def _nydp_wrapper ; Nydp::Date.new self ; end
+  def _nydp_get key ; _nydp_date.lookup key, self           ; end
+  def _nydp_date    ; @__nydp_date ||= Nydp::Date.new(self) ; end
+  def nydp_type     ; :date                                 ; end
+end
+
+class ::Time
+  @@wl = Set.new %i{ year month day hour min sec }
+  def _nydp_time_get key ; send(key) if @@wl.include?(key) ; end
+  def _nydp_get      key ; _nydp_time_get(key.to_s.to_sym) ; end
+  def nydp_type          ; :time                           ; end
 end
 
 class ::Array
-  def _nydp_wrapper ; Nydp::Pair.from_list map &:_nydp_wrapper ; end
+  def _nydp_wrapper ; Nydp::Pair.from_list map &:_nydp_wrapper   ; end
+  def _nydp_inspect ; "[" + map(&:_nydp_inspect).join(" ") + "]" ; end
 end
 
 class ::String
-  # def _nydp_wrapper  ; Nydp::StringAtom.new self  ; end
+  # _hex_ord only works for characters whose #ord is < 256, ie #bytes returns a single-element array
+  # this should allow for two-way conversion of names containing the characters in the regexp
+  # even though we don't use two-way conversion anywhere just yet
+  def _nydp_name_to_rb_name ; self.gsub(/[\x00-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]/) { |chr| "_#{chr._hex_ord}"}.to_sym ; end
   def as_method_name ; self.gsub(/-/, '_').to_sym ; end
   def nydp_type      ; :string                    ; end
-  def to_ruby        ; self                       ; end
+  def _hex_ord       ; ord.to_s(16).rjust(2, '0') ; end
 end
 
 class ::Hash
   include Nydp::Helper
-  def _nydp_get a    ; self[n2r a]           ; end
-  def _nydp_set a, v ; self[n2r a] = n2r(v)  ; end
-  def _nydp_keys     ; keys                  ; end
+  def _nydp_get a    ; self[a]._nydp_wrapper     ; end
+  def _nydp_set a, v ; self[a] = v               ; end
+  def _nydp_keys     ; keys                      ; end
+  def _nydp_inspect  ; "{" + map { |k,v| [k._nydp_inspect, v._nydp_inspect].join(" ")}.join(" ") + "}" ; end
+  def nydp_type      ; :hash                     ; end
 end

data/lib/nydp/date.rb

@@ -18,19 +18,18 @@ 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
-    def nydp_type ; :date                                            ; end
-    def >   other ; is_date?(other) && ruby_date > other.ruby_date   ; end
-    def <   other ; is_date?(other) && ruby_date < other.ruby_date   ; end
-    def ==  other ; is_date?(other) && ruby_date == other.ruby_date  ; end
-    def <=> other ; is_date?(other) && ruby_date <=> other.ruby_date ; end
-    def eql?    d ; self == d                                        ; end
-    def hash      ; ruby_date.hash                                   ; end
-    def is_date? other ; other.is_a? Nydp::Date                                                ; end
-    def -        other ; r2n(ruby_date - (is_date?(other) ? other.ruby_date : other))          ; 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
+    def >        other ; is_date?(other) && ruby_date > other   ; end
+    def <        other ; is_date?(other) && ruby_date < other   ; end
+    def ==       other ; is_date?(other) && ruby_date == other  ; end
+    def <=>      other ; is_date?(other) && ruby_date <=> other ; end
+    def eql?         d ; self == d                              ; end
+    def hash           ; ruby_date.hash                         ; end
+    def is_date? other ; other.is_a? ::Date                     ; end
+    def -        other ; ruby_date - other                      ; end
     def +          int ; int.is_a?(Integer) ? r2n(ruby_date + int) : r2n(change(*int.to_ruby)) ; end
 
     @@pass_through = %i{ monday? tuesday? wednesday? thursday? friday? saturday? sunday? }
@@ -39,7 +38,8 @@ module Nydp
       last_year  next_year  beginning_of_year  end_of_year
       last_month next_month beginning_of_month end_of_month
       last_week  next_week  beginning_of_week  end_of_week
-      yesterday  tomorrow   age
+      yesterday  tomorrow   age                past?
+      future?
     } + @@pass_through
 
     def year               y, m, d, w ; y ; end
@@ -47,6 +47,9 @@ module Nydp
     def day                y, m, d, w ; d ; end
     def week_day           y, m, d, w ; w ; end
 
+    def future?                    *_ ; ruby_date > ::Date.today     ; end
+    def past?                      *_ ; ruby_date < ::Date.today     ; end
+
     def last_year          y, m, d, w ; ruby_date.prev_year          ; end
     def next_year          y, m, d, w ; ruby_date.next_year          ; end
     def beginning_of_year  y, m, d, w ; build(y, 1, 1)               ; end
@@ -76,11 +79,11 @@ module Nydp
       class_eval "def #{n} * ; ruby_date.#{n} ; end"
     end
 
-    def _nydp_keys                ; @@keys.to_a                                                              ; end
-    def dispatch  key, y, m, d, w ; self.send(key, y, m, d, w) if _nydp_keys.include?(key)                   ; end
-    def splat                date ; [date.year, date.month, date.day, date.wday]                             ; end
-    def lookup          key, date ; r2n(dispatch(key.to_s.gsub(/-/, '_').to_sym, *splat(date)))              ; end
-    def _nydp_get             key ; lookup key, ruby_date                                                    ; end
+    def _nydp_keys                ; @@keys.to_a                                                 ; end
+    def dispatch  key, y, m, d, w ; self.send(key, y, m, d, w) if _nydp_keys.include?(key)      ; end
+    def splat                date ; [date.year, date.month, date.day, date.wday]                ; end
+    def lookup          key, date ; r2n(dispatch(key.to_s.gsub(/-/, '_').to_sym, *splat(date))) ; end
+    def _nydp_get             key ; lookup key, ruby_date                                       ; end
     def change       amount, attr
       if    attr == :day   ; (ruby_date + amount)
       elsif attr == :week  ; (ruby_date + (7 * amount))

data/lib/nydp/error.rb

@@ -9,8 +9,7 @@ module Nydp
       @nydp_cause = nydp_cause
     end
 
-    def cause
-      @nydp_cause || super
-    end
+    def nydp_type ; :error               ; end
+    def cause     ; @nydp_cause || super ; end
   end
 end