nydp 0.4.0 → 0.4.6

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,17 +16,37 @@ 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
   def size       ; 1 + (cdr.is_a?(Nydp::Pair) ? cdr.size : 0) ; end
   def inspect    ; "(#{inspect_rest})"                        ; end
+  def &    other ; self.class.from_list((Set.new(self) & other).to_a)           ; end
+  def |    other ; self.class.from_list((Set.new(self) | other).to_a)           ; end
+  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)
-    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
@@ -47,7 +67,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
 
@@ -55,10 +75,6 @@ class Nydp::Pair
     (NIL != other) && (other.respond_to? :car) && (self.car == other.car) && (self.cdr == other.cdr)
   end
 
-  def proper?
-    Nydp::NIL.is?(cdr) || (cdr.is_a?(Nydp::Pair) && cdr.proper?)
-  end
-
   def each &block
     yield car
     cdr.each(&block) unless Nydp::NIL.is?(cdr)

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
 
@@ -45,15 +44,16 @@ module Nydp
 
     SYMBOL_OPERATORS =
       [
-        [ /%/,      "percent-syntax"    ],
         [ /\!/,     "bang-syntax"       ],
         [ /::/,     "colon-colon-syntax"],
         [ /:/,      "colon-syntax"      ],
         [ /&/,      "ampersand-syntax"  ],
+        [ /%/,      "percent-syntax"    ],
         [ /\./,     "dot-syntax"        ],
         [ /\$/,     "dollar-syntax"     ],
         [ /->/,     "arrow-syntax"      ],
         [ /[=][>]/, "rocket-syntax"     ],
+        [ /@/,      "at-syntax"         ],
       ]
 
     def parse_symbol txt
@@ -73,6 +73,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)
@@ -108,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
@@ -129,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, string_token)
+      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, string_token)
+        fragments << string_token.string
       end
 
       if fragments.size == 2

data/lib/nydp/string_atom.rb

@@ -1,32 +1,26 @@
 module Nydp
   class StringAtom
-    attr_accessor :string, :token
-    def initialize string, token=nil
-      @string, @token = string, token
-    end
+    attr_accessor :string
 
-    def nydp_type  ; :string        ; end
-    def to_s       ;  string        ; end
-    def to_ruby    ;  string        ; end
-    def to_sym     ;  string.to_sym ; end
-    def eql? other ; self == other  ; end
-    def inspect    ; string.inspect ; end
-    def hash       ; string.hash    ; end
-    def length     ; string.length  ; end
-    def > other    ; self.string > other.string     ; end
-    def < other    ; self.string < other.string     ; end
-    def * other    ; StringAtom.new(string * other) ; end
+    def initialize string ; @string = string ; end
 
-    def <=> other
-      self < other ? -1 : (self == other ? 0 : 1)
-    end
+    def nydp_type  ; :string                                     ; end
+    def to_s       ; string                                      ; end
+    def to_ruby    ; string                                      ; end
+    def to_sym     ; string.to_sym                               ; end
+    def to_date    ; ::Date.parse(@string)                       ; end
+    def eql? other ; self == other                               ; end
+    def inspect    ; string.inspect                              ; end
+    def hash       ; string.hash                                 ; end
+    def length     ; string.length                               ; end
+    def >    other ; self.string > other.string                  ; end
+    def <    other ; self.string < other.string                  ; end
+    def *    other ; StringAtom.new(string * other)              ; end
+    def <=>  other ; self < other ? -1 : (self == other ? 0 : 1) ; end
+    def +    other ; StringAtom.new "#{@string}#{other}"         ; end
 
     def == other
       other.is_a?(Nydp::StringAtom) && (other.to_s == self.to_s)
     end
-
-    def + other
-      StringAtom.new "#{@string}#{other}"
-    end
   end
 end

data/lib/nydp/symbol.rb

@@ -1,19 +1,22 @@
 class Nydp::Symbol
   class Unbound < StandardError ; end
-
   EMPTY = :""
   attr_accessor :name
-  attr_reader   :hash
+
+  def self.new name
+    special(name.to_s.to_sym) || super
+  end
 
   def initialize name
     name = name.to_s
     @name = name.to_sym
-    @inspection = "|#{name}|" if untidy(name)
-    @hash       = name.hash
+    @inspection = "|#{name.gsub(/\|/, '\|')}|" if untidy(name)
   end
 
+  def hash ; name.hash ; end # can't cache this, it seems to break when unmarshalling
+
   def untidy str
-    (str == "") || (str == nil) || (str =~ /\s/)
+    (str == "") || (str == nil) || (str =~ /[\s\|,\(\)"]/)
   end
 
   def value context=nil
@@ -21,41 +24,51 @@ class Nydp::Symbol
     @value
   end
 
-  def self.mk name, ns
-    name = name.to_sym
+  def self.special name
     return Nydp::NIL if name == :nil
     return Nydp::T   if name == :t
-    sym = ns[name]
-    unless sym
-      sym = new(name)
-      ns[name] = sym
-    end
-    sym
+    nil
   end
 
+  def self.mk name, ns
+    name = name.to_s.to_sym
+    ns[name] ||= new(name)
+  end
 
   def self.find name, ns ; ns[name.to_sym] ;  end
 
-  def nydp_type  ; :symbol                  ; end
-  def inspect    ; @inspection || name.to_s ; end
-  def to_s       ; name.to_s                ; end
-  def to_sym     ; name                     ; end
-  def to_ruby    ; to_sym                   ; end
-  def eql? other ; self == other            ; end
-  def is? nm     ; self.name == nm.to_sym   ; end
-  def > other    ; self.name > other.name   ; end
-  def < other    ; self.name < other.name   ; end
-  def <=> other  ; self.name <=> other.name ; end
+  def nydp_type           ; :symbol                  ; end
+  def inspect             ; @inspection || name.to_s ; end
+  def to_s                ; name.to_s                ; end
+  def to_sym              ; name                     ; end
+  def to_ruby             ; to_sym                   ; end
+  def is?              nm ; self.name == nm.to_sym   ; end
+  def >             other ; self.name > other.name   ; end
+  def <             other ; self.name < other.name   ; end
+  def <=>           other ; self.name <=> other.name ; end
+  def assign value, _=nil ; @value = value           ; end
+  def execute          vm ; vm.push_arg self.value   ; end
 
   def == other
     other.is_a?(Nydp::Symbol) && (self.name == other.name)
   end
 
-  def execute vm
-    vm.push_arg self.value
+  alias eql? ==
+end
+
+class Nydp::FrozenSymbol < Nydp::Symbol
+  @@frozen = { }
+
+  def self.mk name
+    name = name.to_s.to_sym
+    @@frozen[name] ||= new(name)
+  end
+
+  def value _=nil
+    raise Unbound.new("frozen symbol: #{self.inspect}")
   end
 
-  def assign value, _=nil
-    @value = value
+  def assign v, _=nil
+    raise "can't assign to frozen: #{self.inspect}"
   end
 end

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/tokeniser.rb

@@ -3,7 +3,7 @@ require "strscan"
 module Nydp
   class Tokeniser
     BACKSLASH = /\\/.freeze
-    COMMENT   = /;.*$/.freeze
+    COMMENT   = /;;?.*$/.freeze
     QUOTE     = /"/.freeze
     PIPE      = /\|/.freeze
     LIST_PFX  = /[^\s()]*\(/.freeze
@@ -89,7 +89,7 @@ module Nydp
           @finished = true
           return nil
         elsif comment = s.scan(COMMENT)
-          tok = [:comment, comment[1..-1].strip]
+          tok = [:comment, comment.gsub(/^;;?\s*/, '').strip]
         elsif open_str = s.scan(QUOTE)
           tok = [:string_open_delim, open_str]
         elsif open_sym = s.scan(PIPE)

data/lib/nydp/truth.rb

@@ -3,22 +3,24 @@ require 'singleton'
 module Nydp
   class Truth
     include Singleton
-    def init_with *; Nydp::T          ; end
-    def to_s       ; 't'              ; end
-    def inspect    ; 't[nydp::Truth]' ; end
-    def assign  *_ ; self             ; end
-    def nydp_type  ; :truth           ; end
-    def to_ruby    ; true             ; end
+    def init_with *; Nydp::T     ; end
+    def to_s       ; 't'         ; end
+    def inspect    ; 't'         ; end
+    def assign  *_ ; self        ; end
+    def nydp_type  ; :truth      ; end
+    def to_ruby    ; true        ; end
+    def _nydp_get    a ; Nydp::T ; end
+    def _nydp_set a, v ; Nydp::T ; end
   end
 
   class Nil
-    include Singleton
+    include Singleton, Enumerable
     def init_with * ; Nydp::NIL     ; end
     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
@@ -26,7 +28,12 @@ module Nydp
     def inspect     ; "nil"         ; end
     def nydp_type   ; :nil          ; end
     def to_ruby     ; nil           ; end
-    def execute vm  ; vm.push_arg self ; end
+    def execute     vm ; vm.push_arg self ; end
+    def _nydp_get    a ; Nydp::NIL        ; end
+    def _nydp_set a, v ; Nydp::NIL        ; end
+    def each           ;                  ; end # nil behaves like an empty list
+    def &        other ; self             ; end
+    def |        other ; other            ; end
   end
 
   NIL = Nil.instance

data/lib/nydp/version.rb

@@ -1,3 +1,3 @@
 module Nydp
-  VERSION = "0.4.0"
+  VERSION = "0.4.6"
 end

data/lib/nydp/vm.rb

@@ -15,8 +15,6 @@ module Nydp
       @ns           = ns
     end
 
-    def r2n              obj ; super obj, @ns              ; end
-
     def push_instructions ii, ctx
       if @current_instructions && NIL != @current_instructions
         @instructions.push @current_instructions
@@ -118,6 +116,13 @@ module Nydp
       end
       msg << "\n"
       msg << "\n"
+      msg << "\nargs stack"
+      msg << "\n================="
+      args.each_with_index do |args, ix|
+        msg << "\args##{ix} :\n#{args}"
+      end
+      msg << "\n"
+      msg << "\n"
       msg
     end
   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

@@ -7,7 +7,7 @@ describe Nydp::Date do
 
   it "converts ruby Date to Nydp::Date" do
     rd = Date.parse "2015-06-08"
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
     expect(nd).        to be_a Nydp::Date
     expect(nd.to_s).   to eq "2015-06-08"
@@ -33,16 +33,16 @@ describe Nydp::Date do
 
   it "returns date components" do
     rd = Date.parse "2015-06-08"
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
-    expect(nd[:year]). to eq 2015
-    expect(nd[:month]).to eq 6
-    expect(nd[:day]).  to eq 8
+    expect(nd._nydp_get(:year) ).to eq 2015
+    expect(nd._nydp_get(:month)).to eq 6
+    expect(nd._nydp_get(:day)  ).to eq 8
   end
 
   describe "date maths" do
-    let(:d0) { Nydp.r2n Date.today, ns       }
-    let(:d1) { Nydp.r2n (Date.today + 6), ns }
+    let(:d0) { Nydp.r2n Date.today       }
+    let(:d1) { Nydp.r2n (Date.today + 6) }
 
     it "works with builtin minus" do
       minus = Nydp::Builtin::Minus.instance
@@ -120,31 +120,124 @@ describe Nydp::Date do
 
   it "returns relative dates by year" do
     rd = Date.parse "2015-06-08"
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
-    expect(nd[:"last-year"].to_s).          to eq "2014-06-08"
-    expect(nd[:"next-year"].to_s).          to eq "2016-06-08"
-    expect(nd[:"beginning-of-year"].to_s).  to eq "2015-01-01"
-    expect(nd[:"end-of-year"].to_s).        to eq "2015-12-31"
+    expect(nd._nydp_get(:"last-year").to_s).          to eq "2014-06-08"
+    expect(nd._nydp_get(:"next-year").to_s).          to eq "2016-06-08"
+    expect(nd._nydp_get(:"beginning-of-year").to_s).  to eq "2015-01-01"
+    expect(nd._nydp_get(:"end-of-year").to_s).        to eq "2015-12-31"
   end
 
   it "returns relative dates by month" do
     rd = Date.parse "2015-06-08"
-    nd = Nydp.r2n rd, ns
+    nd = Nydp.r2n rd
 
-    expect(nd[:"last-month"].to_s).          to eq "2015-05-08"
-    expect(nd[:"next-month"].to_s).          to eq "2015-07-08"
-    expect(nd[:"beginning-of-month"].to_s).  to eq "2015-06-01"
-    expect(nd[:"end-of-month"].to_s).        to eq "2015-06-30"
+    expect(nd._nydp_get(:"last-month").to_s).          to eq "2015-05-08"
+    expect(nd._nydp_get(:"next-month").to_s).          to eq "2015-07-08"
+    expect(nd._nydp_get(:"beginning-of-month").to_s).  to eq "2015-06-01"
+    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, ns
+    nd = Nydp.r2n rd
+
+    expect(nd._nydp_get(:"last-week").to_s).          to eq "2015-03-05"
+    expect(nd._nydp_get(:"next-week").to_s).          to eq "2015-03-19"
+    expect(nd._nydp_get(:"beginning-of-week").to_s).  to eq "2015-03-09"
+    expect(nd._nydp_get(:"end-of-week").to_s).        to eq "2015-03-15"
+  end
+
+  it "returns age relative to today" do
+    rd = Date.parse "2014-03-12"
+    nd = Nydp.r2n rd
+    allow(::Date).to receive_messages(today: Date.parse("2016-06-21"))
+    expect(nd._nydp_get(:age)).to eq({ years: 2, months: 3 })
+  end
+
+  it "returns a negative age relative to today for a date in the future" do
+    rd = Date.parse "2094-11-18"
+    nd = Nydp.r2n rd
+    allow(::Date).to receive_messages(today: Date.parse("2016-06-21"))
+    expect(nd._nydp_get(:age)).to eq({ years: -78, months: -5 })
+  end
 
-    expect(nd[:"last-week"].to_s).          to eq "2015-03-05"
-    expect(nd[:"next-week"].to_s).          to eq "2015-03-19"
-    expect(nd[:"beginning-of-week"].to_s).  to eq "2015-03-09"
-    expect(nd[:"end-of-week"].to_s).        to eq "2015-03-15"
+  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