nydp 0.4.3 → 0.4.5

data/lib/nydp/function_invocation.rb

@@ -13,9 +13,8 @@ module Nydp
 
     class Base
       include Helper
-      def initialize source_expression, sig=nil
-        @source_expression = source_expression
-        @sig = sig
+      def initialize expr, source, sig=nil
+        @expr, @source, @sig = expr, source, sig
       end
 
       def handle e, f, invoker, *args
@@ -35,9 +34,14 @@ module Nydp
         end
       end
 
-      def inspect ; source.inspect     ; end
-      def source  ; @source_expression ; end
-      def to_s    ; source.to_s        ; end
+      # TODO: speed up compilation by writing custom #lexical_reach for sig-based subclasses (when you know which elements of #expr are lexical symbols)
+      def lexical_reach n
+        @expr.map { |x| x.lexical_reach n}.max
+      end
+
+      def inspect ; @expr.map { |x| x.inspect }.join ' '  ; end
+      def source  ; @source       ; end
+      def to_s    ; source.to_s   ; end
     end
 
     class Invocation_1 < Invocation::Base
@@ -87,8 +91,8 @@ module Nydp
     end
 
     class Invocation_N < Invocation::Base
-      def initialize arg_count, source_expression
-        super source_expression
+      def initialize arg_count, expr, source
+        super expr, source
         @arg_count = arg_count
       end
 
@@ -107,7 +111,7 @@ module Nydp
     class Invocation_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
       end
 
@@ -122,7 +126,7 @@ module Nydp
     class Invocation_SYM < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
       end
 
@@ -137,7 +141,7 @@ module Nydp
     class Invocation_LEX_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @lex0 = expr.car
         @lex1 = expr.cdr.car
       end
@@ -155,7 +159,7 @@ module Nydp
     class Invocation_SYM_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lex = expr.cdr.car
       end
@@ -172,7 +176,7 @@ module Nydp
     class Invocation_SYM_LIT < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lit = expr.cdr.car.expression
       end
@@ -188,7 +192,7 @@ module Nydp
     class Invocation_LEX_LEX_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @lex_0 = expr.car
         @lex_1 = expr.cdr.car
         @lex_2 = expr.cdr.cdr.car
@@ -208,7 +212,7 @@ module Nydp
     class Invocation_SYM_LEX_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lex_0 = expr.cdr.car
         @lex_1 = expr.cdr.cdr.car
@@ -227,7 +231,7 @@ module Nydp
     class Invocation_SYM_LEX_LEX_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lex_0 = expr.cdr.car
         @lex_1 = expr.cdr.cdr.car
@@ -248,7 +252,7 @@ module Nydp
     class Invocation_SYM_LEX_LIT_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lex_0 = expr.cdr.car
         @lit_1 = expr.cdr.cdr.car.expression
@@ -268,7 +272,7 @@ module Nydp
     class Invocation_SYM_LIT_LEX < Invocation::Base
       SIGS << self.name
       def initialize expr, src
-        super src
+        super expr, src
         @sym = expr.car
         @lit_0 = expr.cdr.car.expression
         @lex_1 = expr.cdr.cdr.car
@@ -288,6 +292,10 @@ module Nydp
     extend Helper
     attr_accessor :function_instruction, :argument_instructions
 
+    def lexical_reach n
+      function_instruction.car.lexical_reach(n)
+    end
+
     def self.build expression, bindings
       compiled   = Compiler.compile_each(expression, bindings)
       invocation_sig = compiled.map { |x| sig x }.join("_")
@@ -303,15 +311,15 @@ module Nydp
 
       invocation = cons case expression.size
                         when 1
-                          Invocation::Invocation_1.new(expression)
+                          Invocation::Invocation_1.new(compiled, expression)
                         when 2
-                          Invocation::Invocation_2.new(expression)
+                          Invocation::Invocation_2.new(compiled, expression)
                         when 3
-                          Invocation::Invocation_3.new(expression)
+                          Invocation::Invocation_3.new(compiled, expression)
                         when 4
-                          Invocation::Invocation_4.new(expression)
+                          Invocation::Invocation_4.new(compiled, expression)
                         else
-                          Invocation::Invocation_N.new(expression.size, expression)
+                          Invocation::Invocation_N.new(expression.size, compiled, expression)
                         end
       new invocation, compiled, expression, cname
     end
@@ -327,7 +335,7 @@ module Nydp
       vm.push_ctx_instructions argument_instructions
     end
 
-    def inspect ; @source.inspect ; end
-    def to_s    ; @source.to_s    ; end
+    def inspect ; @function_instruction.inspect ; end
+    def to_s    ; @source.to_s                  ; end
   end
 end

data/lib/nydp/helper.rb

@@ -1,7 +1,17 @@
 module Nydp
   module AutoWrap
-    def _nydp_wrapper ; self ; end
-    def to_ruby       ; self ; end
+    # 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
+  end
+
+  class Struct < ::Struct
+    include AutoWrap
+    def _nydp_whitelist ; members ; end
   end
 
   module Converter

data/lib/nydp/interpreted_function.rb

@@ -5,8 +5,8 @@ require 'nydp/closure'
 module Nydp
   class PopArg
     def self.execute vm ; vm.args.pop ; end
-    def self.to_s       ; ""         ; end
-    def self.inspect    ; "#pop_arg" ; end
+    def self.to_s       ; ""          ; end
+    def self.inspect    ; "#pop_arg"  ; end
   end
 
   class InterpretedFunction
@@ -16,42 +16,22 @@ module Nydp
 
     attr_accessor :arg_names, :body, :context_builder
 
-    def invoke_1 vm, parent_context
-      vm.push_instructions self.body, set_args_0(parent_context)
-    end
-
-    def invoke_2 vm, parent_context, arg
-      vm.push_instructions self.body, set_args_1(parent_context, arg)
-    end
-
-    def invoke_3 vm, parent_context, arg_0, arg_1
-      vm.push_instructions self.body, set_args_2(parent_context, arg_0, arg_1)
-    end
-
-    def invoke_4 vm, parent_context, arg_0, arg_1, arg_2
-      vm.push_instructions self.body, set_args_3(parent_context, arg_0, arg_1, arg_2)
-    end
-
-    def invoke vm, parent_context, arg_values
-      vm.push_instructions self.body, set_args(parent_context, arg_values)
-    end
-
-    def setup_context context, names, values
-      if pair? names
-        context.set names.car, values.car
-        setup_context context, names.cdr, values.cdr
-      elsif NIL != names
-        context.set names, values
-      end
+    def lexical_reach n
+      body.map { |b| b.lexical_reach(n - 1)  }.max
     end
 
     def self.build arg_list, body, bindings
       my_params = { }
       index_parameters arg_list, my_params
-      ifn = Nydp::InterpretedFunction.new
+      body = compile_body body, cons(my_params, bindings), []
+      reach = body.map { |b| b.lexical_reach(-1)  }.max
+
+      ifn_klass     = reach >= 0 ? InterpretedFunctionWithClosure : InterpretedFunctionWithoutClosure
+      ifn           = ifn_klass.new
       ifn.arg_names = arg_list
+      ifn.body      = body
+
       ifn.extend Nydp::LexicalContextBuilder.select arg_list
-      ifn.body = compile_body body, cons(my_params, bindings), []
       ifn
     end
 
@@ -62,6 +42,11 @@ module Nydp
       if Nydp::NIL.is? rest
         return Pair.from_list(instructions)
       else
+        # PopArg is necessary because each expression pushes an arg onto the arg stack.
+        # we only need to keep the arg pushed by the last expression in a function
+        # so we need the following line in order to remove unwanted args from the stack.
+        # Each expression at some executes vm.push_arg(thing)
+        # TODO find a more intelligent way to do this, eg change the meaning of vm or of push_arg in the expression vm.push_arg(thing)
         instructions << PopArg
         compile_body rest, bindings, instructions
       end
@@ -76,19 +61,62 @@ module Nydp
       end
     end
 
-    def execute vm
-      # TODO do not create a new Closure if this function does not refer to it
-      #      - including top-level function definitions
-      #      - and any other function that does not refer to any lexically-bound outer variable
-      #      - for example (fn (x) (* x x)) in (map λx(* x x) things) does not need a closure, because
-      #        the function does not refer to any lexical variable outside itself.
-      vm.push_arg Closure.new(self, vm.current_context)
-    end
-
     def nydp_type ; "fn" ; end
     def inspect   ; to_s ; end
     def to_s
       "(fn #{arg_names.inspect} #{body.map { |b| b.inspect}.join(' ')})"
     end
   end
+
+  class InterpretedFunctionWithClosure < InterpretedFunction
+    def invoke_1 vm, ctx
+      vm.push_instructions self.body, set_args_0(ctx)
+    end
+
+    def invoke_2 vm, ctx, arg
+      vm.push_instructions self.body, set_args_1(ctx, arg)
+    end
+
+    def invoke_3 vm, ctx, arg_0, arg_1
+      vm.push_instructions self.body, set_args_2(ctx, arg_0, arg_1)
+    end
+
+    def invoke_4 vm, ctx, arg_0, arg_1, arg_2
+      vm.push_instructions self.body, set_args_3(ctx, arg_0, arg_1, arg_2)
+    end
+
+    def invoke vm, ctx, arg_values
+      vm.push_instructions self.body, set_args(ctx, arg_values)
+    end
+
+    def execute vm
+      vm.push_arg Closure.new(self, vm.current_context)
+    end
+  end
+
+  class InterpretedFunctionWithoutClosure < InterpretedFunction
+    def invoke_1 vm
+      vm.push_instructions self.body, set_args_0(vm.current_context)
+    end
+
+    def invoke_2 vm, arg
+      vm.push_instructions self.body, set_args_1(vm.current_context, arg)
+    end
+
+    def invoke_3 vm, arg_0, arg_1
+      vm.push_instructions self.body, set_args_2(vm.current_context, arg_0, arg_1)
+    end
+
+    def invoke_4 vm, arg_0, arg_1, arg_2
+      vm.push_instructions self.body, set_args_3(vm.current_context, arg_0, arg_1, arg_2)
+    end
+
+    def invoke vm, arg_values
+      vm.push_instructions self.body, set_args(vm.current_context, arg_values)
+    end
+
+    def execute vm
+      vm.push_arg self
+    end
+  end
 end

data/lib/nydp/literal.rb

@@ -18,7 +18,7 @@ module Nydp
     def nydp_type ; :literal            ; end
     def inspect   ; @expression.inspect ; end
     def to_s      ; @expression.to_s    ; end
-    def to_ruby   ; n2r @expression ; end
+    def to_ruby   ; n2r @expression     ; end
 
     def coerce _
       [_, expression]

data/lib/nydp/pair.rb

@@ -16,7 +16,8 @@ class Nydp::Pair
   def cddr       ; cdr.cdr                                    ; end
   def car= thing ; @car = thing ; @_hash = nil                ; end
   def cdr= thing ; @cdr = thing ; @_hash = nil                ; end
-  def hash       ; @_hash ||= (car.hash + cdr.hash)           ; end
+  # def hash       ; @_hash ||= (car.hash + cdr.hash)           ; end
+  def hash       ; (car.hash + cdr.hash)                      ; end # can't cache hash of symbol, breaks when unmarshalling
   def eql? other ; self == other                              ; end
   def copy       ; cons(car, cdr.copy)                        ; end
   def +    other ; copy.append other                          ; end
@@ -27,6 +28,16 @@ class Nydp::Pair
   def -    other ; self.class.from_list((Set.new(self) - other).to_a)           ; end
   def proper?    ; Nydp::NIL.is?(cdr) || (cdr.is_a?(Nydp::Pair) && cdr.proper?) ; end
 
+  def index_of x
+    if x == car
+      0
+    elsif pair?(cdr)
+      1 + cdr.index_of(x)
+    else
+      nil
+    end
+  end
+
   # returns Array of elements after calling #n2r on each element
   def to_ruby list=[]
     list << n2r(car)
@@ -51,7 +62,7 @@ class Nydp::Pair
     if n >= list.size
       last
     else
-      new list[n], from_list(list, last, n+1)
+      Nydp::Pair.new list[n], from_list(list, last, n+1)
     end
   end
 

data/lib/nydp/parser.rb

@@ -54,6 +54,7 @@ module Nydp
         [ /\$/,     "dollar-syntax"     ],
         [ /->/,     "arrow-syntax"      ],
         [ /[=][>]/, "rocket-syntax"     ],
+        [ /@/,      "at-syntax"         ],
       ]
 
     def parse_symbol txt
@@ -73,6 +74,8 @@ module Nydp
         Pair.from_list [sym(:unquote), parse_symbol($1)]
       when /^\.$/
         sym txt
+      when /^@$/
+        sym txt
       else
         SYMBOL_OPERATORS.each do |rgx, name|
           syms = txt.split(rgx, -1)

data/lib/nydp/symbol_lookup.rb

@@ -11,17 +11,17 @@ module Nydp
       bindings
     end
 
-    def self.build name, bindings
-      bindings = skip_empty bindings
-      depth = 0
-      while NIL != bindings
-        here = bindings.car
+    def self.build name, original_bindings
+      effective_bindings = skip_empty original_bindings
+      depth    = 0
+      while NIL != effective_bindings
+        here = effective_bindings.car
         if here.key? name
           binding_index = here[name]
-          return ContextSymbol.build(depth, name, binding_index)
+          return ContextSymbol.build(depth, name, binding_index, original_bindings.index_of(here))
         else
           depth += 1
-          bindings = skip_empty bindings.cdr
+          effective_bindings = skip_empty effective_bindings.cdr
         end
       end
       name

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.4.3"
+  VERSION = "0.4.5"
 end

data/nydp.gemspec

@@ -18,8 +18,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency 'rspec', '~> 3.1'
-  spec.add_development_dependency 'rspec_numbering_formatter'
+  spec.add_development_dependency "rake", "~> 12"
+  spec.add_development_dependency 'rspec' #, '~> 3.1'
 end

data/spec/date_spec.rb

@@ -138,6 +138,40 @@ describe Nydp::Date do
     expect(nd._nydp_get(:"end-of-month").to_s).        to eq "2015-06-30"
   end
 
+  it "calculates end-of-month all year around" do
+    expect(Nydp.r2n(Date.parse("2015-01-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-01-31"
+    expect(Nydp.r2n(Date.parse("2015-02-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-02-28"
+    expect(Nydp.r2n(Date.parse("2016-02-08"))._nydp_get(:"end-of-month").to_s).to eq "2016-02-29"
+    expect(Nydp.r2n(Date.parse("2015-03-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-03-31"
+    expect(Nydp.r2n(Date.parse("2015-04-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-04-30"
+    expect(Nydp.r2n(Date.parse("2015-05-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-05-31"
+    expect(Nydp.r2n(Date.parse("2015-06-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-06-30"
+    expect(Nydp.r2n(Date.parse("2015-07-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-07-31"
+    expect(Nydp.r2n(Date.parse("2015-08-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-08-31"
+    expect(Nydp.r2n(Date.parse("2015-09-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-09-30"
+    expect(Nydp.r2n(Date.parse("2015-10-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-10-31"
+    expect(Nydp.r2n(Date.parse("2015-11-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-11-30"
+    expect(Nydp.r2n(Date.parse("2015-12-08"))._nydp_get(:"end-of-month").to_s).to eq "2015-12-31"
+  end
+
+  it "manages leap years" do
+    rd = Date.parse "2020-02-08"
+    nd = Nydp.r2n rd
+
+    expect(nd._nydp_get(:"last-month").to_s).          to eq "2020-01-08"
+    expect(nd._nydp_get(:"next-month").to_s).          to eq "2020-03-08"
+    expect(nd._nydp_get(:"beginning-of-month").to_s).  to eq "2020-02-01"
+    expect(nd._nydp_get(:"end-of-month").to_s).        to eq "2020-02-29"
+
+    rd = Date.parse "2020-02-28"
+    nd = Nydp.r2n rd
+    expect(nd._nydp_get(:"tomorrow").to_s).            to eq "2020-02-29"
+
+    rd = Date.parse "2020-03-01"
+    nd = Nydp.r2n rd
+    expect(nd._nydp_get(:"yesterday").to_s).           to eq "2020-02-29"
+  end
+
   it "returns relative dates by week" do
     rd = Date.parse "2015-03-12"
     nd = Nydp.r2n rd
@@ -161,4 +195,49 @@ describe Nydp::Date do
     allow(::Date).to receive_messages(today: Date.parse("2016-06-21"))
     expect(nd._nydp_get(:age)).to eq({ years: -78, months: -5 })
   end
+
+  describe "#change" do
+    let(:nd) { Nydp::Date.new(Date.parse("1965-06-08")) }
+
+    it "advances by weeks" do
+      expect((nd.change  1, :week).to_s).to eq "1965-06-15"
+      expect((nd.change -1, :week).to_s).to eq "1965-06-01"
+      expect((nd.change -2, :week).to_s).to eq "1965-05-25"
+      expect((nd.change  2, :week).to_s).to eq "1965-06-22"
+    end
+
+    it "advances by days" do
+      expect((nd.change  1, :day).to_s).to eq "1965-06-09"
+      expect((nd.change -1, :day).to_s).to eq "1965-06-07"
+      expect((nd.change -2, :day).to_s).to eq "1965-06-06"
+      expect((nd.change  2, :day).to_s).to eq "1965-06-10"
+    end
+
+    it "advances by months" do
+      expect((nd.change  1, :month).to_s).to eq "1965-07-08"
+      expect((nd.change -1, :month).to_s).to eq "1965-05-08"
+      expect((nd.change -2, :month).to_s).to eq "1965-04-08"
+      expect((nd.change  2, :month).to_s).to eq "1965-08-08"
+    end
+
+    it "advances by years" do
+      expect((nd.change  1, :year).to_s).to eq "1966-06-08"
+      expect((nd.change -1, :year).to_s).to eq "1964-06-08"
+      expect((nd.change -2, :year).to_s).to eq "1963-06-08"
+      expect((nd.change  2, :year).to_s).to eq "1967-06-08"
+    end
+
+    it "handles leap years and small months" do
+      d = Nydp::Date.new(Date.parse("2019-12-31"))
+
+      expect(d.change( 2, :month).to_s).to eq "2020-02-29"
+      expect(d.change(12, :month).to_s).to eq "2020-12-31"
+      expect(d.change(14, :month).to_s).to eq "2021-02-28"
+      expect(d.change( 6, :month).to_s).to eq "2020-06-30"
+      expect(d.change( 7, :month).to_s).to eq "2020-07-31"
+
+      d = Nydp::Date.new(Date.parse("2020-02-29"))
+      expect(d.change(12, :month).to_s).to eq "2021-02-28"
+    end
+  end
 end