nydp-kalendor 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 019255c54a1f7e930d7e58a1d06bd0a852f12b63
+  data.tar.gz: a2e936010e6057f0bfa1ca1da3b42cd5e83df0b5
+SHA512:
+  metadata.gz: 8252ed60cf0e8bf3b126c7fffb7f14a8024c554d1e8e4782f07c135c967e0ebd8777e29cf32d0f3656ea2d6ec74d2c4bd636388fd0a2934e3a42d8fb1d8284d0
+  data.tar.gz: 68bcf3619bf0dab1153f975b0f3a44e45a76ddb35233e829bea0551b786feefc63005e6f0a62dfe51fb9773c77be7bcfc21679cc0a4eb259092375da1736ac15

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+lib/lisp/scratch
+.#*
+bm.txt
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nydp-kalendor.gemspec
+gemspec

data/MIT-LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Conan Dalton conan@conandalton.net
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Nydp::Kalendor
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nydp-kalendor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nydp-kalendor
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/nydp-kalendor/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/nydp-tests

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'nydp'
+require 'nydp/kalendor'
+
+Nydp.tests *ARGV.map(&:to_sym)

data/lib/lisp/kalendor-000-core.nydp

@@ -0,0 +1,96 @@
+;; kalendor builtins:
+;;
+;; named-kalendor management
+;;
+;; * kalendor/add    (name label builder) ;; create and return a new instance (overriding name if existing)
+;; * kalendor/find   (name)               ;; return the instance with this name
+;; * kalendor/delete (name)               ;; return the instance with this name
+;; * kalendor/names                       ;; return a list of names
+;; * kalendor/list                        ;; return named-kalendor instances
+;;
+;; simple builders
+;;
+;; * kalendor-build/named
+;; * kalendor-build/annual
+;; * kalendor-build/union
+;; * kalendor-build/intersect
+;; * kalendor-build/subtract
+;; * kalendor-build/list
+;; * kalendor-build/interval
+;; * kalendor-build/weekday
+;; * kalendor-build/month
+;;
+;; retrieve dates
+;;
+;; * kalendor/dates (k from upto) ;; where k is a name, a named kalendor, or a builder
+;;
+;;
+
+(assign kalendor/substitutions
+   {
+     named     'kalendor-build/named
+     weekday   'kalendor-build/weekday
+     annual    'kalendor-build/annual
+     union     'kalendor-build/union
+     intersect 'kalendor-build/intersect
+     subtract  'kalendor-build/subtract
+     list      'kalendor-build/list
+     interval  'kalendor-build/interval
+     weekday   'kalendor-build/weekday
+     month     'kalendor-build/month
+     lookup    'kalendor/find
+   })
+
+(def kalendor/replace-names (expr)
+  (if (and (sym? expr) (kalendor/find expr))
+      `(kalendor/find ',expr)
+      (and (sym? expr) (hash-get kalendor/substitutions expr))
+      (hash-get kalendor/substitutions expr)
+      (pair? expr)
+      (cons (kalendor/replace-names (car expr))
+            (kalendor/replace-names (cdr expr)))
+      expr))
+
+(def kalendor/test (kal from upto)
+  (map to-string (kalendor/dates kal from upto)))
+
+(mac kalendor (name label expr)
+  `(kalendor/add ,(kalendor/replace-names `(named ',name ,label ,expr))))
+
+(kalendor mondays    { en "Mondays"    fr "lundis"     de "Montag"     } (weekday 1))
+(kalendor tuesdays   { en "Tuesdays"   fr "mardis"     de "Dienstag"   } (weekday 2))
+(kalendor wednesdays { en "Wednesdays" fr "mercredis"  de "Mittwoch"   } (weekday 3))
+(kalendor thursdays  { en "Thursdays"  fr "jeudis"     de "Donnerstag" } (weekday 4))
+(kalendor fridays    { en "Fridays"    fr "vendredis"  de "Freitag"    } (weekday 5))
+(kalendor saturdays  { en "Saturdays"  fr "samedis"    de "Samstag"    } (weekday 6))
+(kalendor sundays    { en "Sundays"    fr "dimanches"  de "Sonntag"    } (weekday 0))
+(kalendor weekends   { en "weekends"   fr "weekends"   de "Wochenende" } (union saturdays sundays))
+
+(kalendor a-01-jan     { en "1 jan"      fr "1 janv"     de "1. Januar"  } (annual  1  1))
+(kalendor a-17-mar     { en "17 mar"     fr "17 mars"    de "17. Marz"   } (annual 17  3))
+(kalendor a-01-may     { en "1 may"      fr "1 mai"      de "1. May"     } (annual  1  5))
+(kalendor a-08-may     { en "8 may"      fr "8 mai"      de "8. May"     } (annual  8  5))
+(kalendor a-01-jun     { en "1 jun"      fr "1 juin"     de "1. Juni"    } (annual  1  6))
+(kalendor a-14-jul     { en "14 jul"     fr "14 jul"     de "14. Juli"   } (annual 14  7))
+(kalendor a-01-jun     { en "1 aug"      fr "1 août"     de "1. Aug"     } (annual  1  8))
+(kalendor a-15-aug     { en "15 aug"     fr "15 août"    de "15. Aug"    } (annual 15  8))
+(kalendor a-01-nov     { en "1 nov"      fr "1 nov"      de "1. Nov"     } (annual  1 11))
+(kalendor a-25-dec     { en "25 dec"     fr "25 déc"     de "25. Dez"    } (annual 25 12))
+(kalendor a-26-dec     { en "26 dec"     fr "26 déc"     de "26. Dez"    } (annual 26 12))
+
+(kalendor first-monday-may { en "First monday May" fr "premier lundi mai"    de "Erste Montag May"   } (intersect (weekday 1 1)  (month  5)))
+(kalendor first-monday-jun { en "First monday Jun" fr "premier lundi juin"   de "Erste Montag Juni"  } (intersect (weekday 1 1)  (month  6)))
+(kalendor first-monday-aug { en "First monday Aug" fr "premier lundi août"   de "Erste Montag Aug"   } (intersect (weekday 1 1)  (month  8)))
+(kalendor last-monday-oct  { en "Last monday oct"  fr "dernier lundi oct"    de "Letzte Montag Oct"  } (intersect (weekday 1 -1) (month 10)))
+
+(kalendor easter
+          { en "Easter" fr "Pacques" de "Ostern" }
+          (list "2001-04-15" "2002-03-31" "2003-04-20" "2004-04-11" "2005-03-27" "2006-04-16" "2007-04-08" "2008-03-23" "2009-04-12"
+                "2010-04-04" "2011-04-24" "2012-04-08" "2013-03-31" "2014-04-20" "2015-04-05" "2016-03-27" "2017-04-16" "2018-04-01" "2019-04-21"
+                "2020-04-12" "2021-04-04" "2022-04-17" "2023-04-09" "2024-03-31" "2025-04-20"))
+
+;; (kalendor
+;;   (subtract (interval "2016-06-01" "2016-08-31")
+;;             (union (union saturdays sundays))
+;;    )
+;;  )

data/lib/lisp/tests/date-list-examples.nydp

@@ -0,0 +1,24 @@
+(examples-for kalendor-build/list
+  ("single date"
+   (kalendor/test (kalendor list-test-1
+                            nil
+                            (list "1984-09-01"))
+                  "1900-01-01"
+                  "1999-12-31")
+   ("1984-09-01"))
+
+  ("list of dates"
+   (kalendor/test (kalendor list-test-2
+                            nil
+                            (list "1984-06-21" "1949-10-03" "1982-06-08"))
+                  "1900-01-01"
+                  "1999-12-31")
+   ("1984-06-21" "1949-10-03" "1982-06-08"))
+
+  ("constrained list of dates"
+   (kalendor/test (kalendor list-test-3
+                            nil
+                            (list "1984-06-21" "1999-02-11" "1949-10-03" "1882-06-08" "2012-06-08"))
+                                  "1950-01-01"
+                                  "1999-12-31")
+   ("1984-06-21" "1999-02-11")))

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

@@ -0,0 +1,9 @@
+(examples-for kalendor-build/intrsect
+  ("every weekend in a given interval"
+   (kalendor/test (kalendor "intersect-text" nil (intersect (union (weekday 6)
+                                                                   (weekday 0))
+                                                            (interval "2016-05-01" "2016-06-30")))
+                  "2016-06-01"
+                  "2016-08-31")
+   ("2016-06-04" "2016-06-05" "2016-06-11" "2016-06-12"
+    "2016-06-18" "2016-06-19" "2016-06-25" "2016-06-26")))

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

@@ -0,0 +1,36 @@
+(examples-for kalendor-build/interval
+  ("returns nothing when requested interval is before given interval"
+   (kalendor/test (kalendor-build/interval "2016-06-01" "2016-06-30")
+                  "2000-01-01"
+                  "2000-12-31")
+   ())
+
+  ("returns some dates when overlapping before"
+   (kalendor/test (kalendor-build/interval "2016-06-01" "2016-06-30")
+                  "2000-01-01"
+                  "2016-06-08")
+   ( "2016-06-01" "2016-06-02" "2016-06-03" "2016-06-04" "2016-06-05" "2016-06-06" "2016-06-07" "2016-06-08"))
+
+  ("returns some dates when overlapping inside"
+   (kalendor/test (kalendor-build/interval "2016-06-01" "2016-06-30")
+                  "2016-06-14"
+                  "2016-06-17")
+   ( "2016-06-14" "2016-06-15" "2016-06-16" "2016-06-17"))
+
+  ("returns all dates when overlapping outside"
+   (kalendor/test (kalendor-build/interval "2016-06-21" "2016-06-24")
+                  "2000-01-14"
+                  "2020-12-31")
+   ( "2016-06-21" "2016-06-22" "2016-06-23" "2016-06-24"))
+
+  ("returns some dates when overlapping after"
+   (kalendor/test (kalendor-build/interval "2016-06-01" "2016-06-30")
+                  "2016-06-28"
+                  "2020-12-31")
+   ( "2016-06-28" "2016-06-29" "2016-06-30"))
+
+  ("returns no dates when entirely after"
+   (kalendor/test (kalendor-build/interval "2016-06-01" "2016-06-30")
+                  "2016-07-01"
+                  "2020-12-31")
+   ()))

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

@@ -0,0 +1,16 @@
+(examples-for kalendor-build/weekday
+  ("tuesdays"
+   (kalendor/test (kalendor-build/weekday 2) "2016-09-01" "2016-09-30")
+   ("2016-09-06" "2016-09-13" "2016-09-20" "2016-09-27"))
+
+  ("mondays"
+   (kalendor/test (kalendor-build/weekday 1) "2016-10-01" "2016-10-31")
+   ("2016-10-03" "2016-10-10" "2016-10-17" "2016-10-24" "2016-10-31"))
+
+  ("second wednesdays"
+   (kalendor/test (kalendor-build/weekday 3 2) "2016-01-01" "2016-12-31")
+   ("2016-01-13" "2016-02-10" "2016-03-09" "2016-04-13" "2016-05-11" "2016-06-08" "2016-07-13" "2016-08-10" "2016-09-14" "2016-10-12" "2016-11-09" "2016-12-14"))
+
+  ("3rd-last thursdays of 2015"
+   (kalendor/test (kalendor-build/weekday 4 -3) "2015-01-01" "2015-12-31")
+   ("2015-01-15" "2015-02-12" "2015-03-12" "2015-04-16" "2015-05-14" "2015-06-11" "2015-07-16" "2015-08-13" "2015-09-10" "2015-10-15" "2015-11-12" "2015-12-17")))

data/lib/nydp/kalendor.rb

@@ -0,0 +1,100 @@
+require "kalendor"
+require "kalendor/instance/store"
+require "nydp"
+require "nydp/kalendor/version"
+
+module Nydp
+  class Namespace
+    attr_accessor :kalendor_store
+  end
+
+  module Kalendor
+    class Plugin
+      def name ; "Nydp/Kalendor plugin" ; end
+
+      def relative_path name
+        File.expand_path(File.join File.dirname(__FILE__), name)
+      end
+
+      def base_path ; relative_path "../lisp/" ; end
+
+      def load_rake_tasks ; end
+
+      def loadfiles
+        Dir.glob(relative_path '../lisp/kalendor-*.nydp').sort
+      end
+
+      def testfiles
+        Dir.glob(relative_path '../lisp/tests/**/*.nydp')
+      end
+
+      def setup ns
+        store = ns.kalendor_store = ::Kalendor::Instance::Store.new
+        factory = ::Kalendor::Factory.new
+        Symbol.mk("kalendor/add"            ,  ns).assign(Nydp::Kalendor::Builtin::Store::Add        .new store, factory)
+        Symbol.mk("kalendor/find"           ,  ns).assign(Nydp::Kalendor::Builtin::Store::Find       .new store, factory)
+        Symbol.mk("kalendor/delete"         ,  ns).assign(Nydp::Kalendor::Builtin::Store::Delete     .new store, factory)
+        Symbol.mk("kalendor/names"          ,  ns).assign(Nydp::Kalendor::Builtin::Store::Names      .new store, factory)
+        Symbol.mk("kalendor/list"           ,  ns).assign(Nydp::Kalendor::Builtin::Store::List       .new store, factory)
+        Symbol.mk("kalendor/dates"          ,  ns).assign(Nydp::Kalendor::Builtin::Dates             .new store, factory)
+        Symbol.mk("kalendor-build/named"    ,  ns).assign(Nydp::Kalendor::Builtin::Builder::Named    .new store, factory)
+        Symbol.mk("kalendor-build/annual"   ,  ns).assign(Nydp::Kalendor::Builtin::Builder::Annual   .new store, factory)
+        Symbol.mk("kalendor-build/union"    ,  ns).assign(Nydp::Kalendor::Builtin::Builder::Union    .new store, factory)
+        Symbol.mk("kalendor-build/intersect",  ns).assign(Nydp::Kalendor::Builtin::Builder::Intersect.new store, factory)
+        Symbol.mk("kalendor-build/subtract" ,  ns).assign(Nydp::Kalendor::Builtin::Builder::Subtract .new store, factory)
+        Symbol.mk("kalendor-build/list"     ,  ns).assign(Nydp::Kalendor::Builtin::Builder::DateList .new store, factory)
+        Symbol.mk("kalendor-build/interval" ,  ns).assign(Nydp::Kalendor::Builtin::Builder::Interval .new store, factory)
+        Symbol.mk("kalendor-build/weekday"  ,  ns).assign(Nydp::Kalendor::Builtin::Builder::Weekday  .new store, factory)
+        Symbol.mk("kalendor-build/month"    ,  ns).assign(Nydp::Kalendor::Builtin::Builder::Month    .new store, factory)
+      end
+    end
+
+    module Builtin
+      class Base
+        include Nydp::Builtin::Base
+
+        def initialize store, factory
+          @store = store
+          @factory = factory
+        end
+
+        def lookup       kal
+          kal = n2r kal
+          kal.respond_to?(:get_dates) ? kal : @store.find(kal)
+        end
+
+        def name         ; "kalendor/#{super}"     ; end
+      end
+
+      class Dates < Base
+        include ::Kalendor::DateHelper
+        def invoke_4 vm, kal, from, upto
+          vm.push_arg vm.r2n lookup(kal).get_dates(to_date(from), to_date(upto)).to_a
+        end
+      end
+
+      module Store
+        class Add    < Base ; def builtin_invoke_2  vm, kal ; vm.push_arg vm.r2n @store.add n2r kal     ; end ; end
+        class Find   < Base ; def builtin_invoke_2 vm, name ; vm.push_arg vm.r2n @store.find n2r name   ; end ; end
+        class Delete < Base ; def builtin_invoke_2 vm, name ; vm.push_arg vm.r2n @store.delete n2r name ; end ; end
+        class Names  < Base ; def builtin_invoke_1       vm ; vm.push_arg vm.r2n @store.names           ; end ; end
+        class List   < Base ; def builtin_invoke_1       vm ; vm.push_arg vm.r2n @store.list            ; end ; end
+      end
+
+      module Builder
+        class Weekday   < Base ; def builtin_invoke_3         vm, day, nth ; vm.push_arg @factory.weekday day, nth                 ; end
+                                 def builtin_invoke_2              vm, day ; vm.push_arg @factory.weekday day                      ; end ; end
+        class Annual    < Base ; def builtin_invoke_3      vm, date, month ; vm.push_arg @factory.annual date, month               ; end ; end
+        class Union     < Base ; def builtin_invoke               vm, args ; vm.push_arg @factory.union *(n2r args)                ; end ; end
+        class Intersect < Base ; def builtin_invoke               vm, args ; vm.push_arg @factory.intersect *(n2r args)            ; end ; end
+        class Subtract  < Base ; def builtin_invoke_3       vm, keep, toss ; vm.push_arg @factory.subtract keep, toss              ; end ; end
+        class DateList  < Base ; def builtin_invoke               vm, args ; vm.push_arg @factory.list *(n2r args)                 ; end ; end
+        class Interval  < Base ; def builtin_invoke_3       vm, from, upto ; vm.push_arg @factory.interval from, upto              ; end ; end
+        class Month     < Base ; def builtin_invoke_2                vm, m ; vm.push_arg @factory.month m                          ; end ; end
+        class Named     < Base ; def builtin_invoke_4 vm, name, label, kal ; vm.push_arg @factory.named n2r(name), n2r(label), kal ; end ; end
+      end
+    end
+  end
+end
+
+Nydp.plug_in Nydp::Kalendor::Plugin.new

data/lib/nydp/kalendor/version.rb

@@ -0,0 +1,5 @@
+module Nydp
+  module Kalendor
+    VERSION = "0.0.1"
+  end
+end

data/nydp-kalendor.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nydp/kalendor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nydp-kalendor"
+  spec.version       = Nydp::Kalendor::VERSION
+  spec.authors       = ["conanite"]
+  spec.email         = ["conan@conandalton.net"]
+  spec.summary       = %q{nydp integration for Kalendor gem}
+  spec.description   = %q{provides functions and macros to simplify date management within nydp}
+  spec.homepage      = "https://github.com/conanite/nydp-kalendor"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'rspec_numbering_formatter'
+
+  spec.add_dependency             'nydp',     '~> 0.2'
+  spec.add_dependency             'kalendor'
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: nydp-kalendor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- conanite
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec_numbering_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nydp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: kalendor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: provides functions and macros to simplify date management within nydp
+email:
+- conan@conandalton.net
+executables:
+- nydp-tests
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- MIT-LICENSE.txt
+- README.md
+- Rakefile
+- bin/nydp-tests
+- lib/lisp/kalendor-000-core.nydp
+- lib/lisp/tests/date-list-examples.nydp
+- lib/lisp/tests/intersect-examples.nydp
+- lib/lisp/tests/interval-examples.nydp
+- lib/lisp/tests/weekday-examples.nydp
+- lib/nydp/kalendor.rb
+- lib/nydp/kalendor/version.rb
+- nydp-kalendor.gemspec
+homepage: https://github.com/conanite/nydp-kalendor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: nydp integration for Kalendor gem
+test_files: []