ocarina_of_time 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c76b5c32fdda58e5ba617450ad0f9acee53b290a
+  data.tar.gz: caddfbedba3fe902dce0c19604a71388cd2633d5
+SHA512:
+  metadata.gz: 297211847d7ab989b49df4ccdaa6fcf8955ea1abef018dcded9b0b0255a9706d8573e399fcadfd1bf332839b3f6e6bdfb725968db9d5c2210a8e86b4c89f7185
+  data.tar.gz: 581dd32dc21fa8bad047554d9dcdeed68207a0f6f2c072c108797014ba7cc62256e44545b3b724c4b7ffdc2ec9d2147e286461acf5ab48c7f0fec099668af44b

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.0
+before_install: gem install bundler -v 1.14.3

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at kgruber1@emich.edu. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Kent Gruber
+
+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,167 @@
+# Ocarina of Time
+![Alt Text](http://i.imgur.com/213eY1X.png)
+
+Play this song near a blue Time Block.
+
+```
+------------------------------------------------
+-( > )---------( > )----------------------------
+----------( v )-----------( > )-----------------
+-----( A )-----------( A )----------------------
+```
+
+## Installation
+
+    $ gem install ocarina_of_time
+
+## Usage
+
+```ruby
+require 'ocarina_of_time'
+
+timeline = OcarinaOfTime::Timeline.new
+
+# beginning of time
+timeline.beginning
+# => 2017-02-21 10:10:16 -0500
+
+# check for beginning of time
+timeline.beginning?
+
+# end of time
+timeline.ending
+# => false
+
+# check for end of time
+timeline.ending?
+# => false
+
+# set beginning of end of time
+timeline.ending = Time.now
+
+timeline.ending?
+# => true
+
+timeline.ending
+# => 2017-02-21 10:15:45 -0500
+```
+
+## Timeline
+A timeline is a way of displaying a list of events in chronological order, sometimes described as a project artifact. Timelines can use any time scale, depending on the subject and data. Most timelines use a linear scale, where a unit of distance is equal to a set amount of time.
+ 
+```ruby
+# will return a unique id number for the timeline event
+timeline.events.add(label: "Example 1")
+# => "e41fdc5c-6a8d-4d85-addb-27b6f81666e9"
+
+# you can remove a timeline event by id number
+timeline.events.delete(id: "e41fdc5c-6a8d-4d85-addb-27b6f81666e9")
+# => true
+
+# or you can remove a timeline event by time, if
+# it exists -- maybe it's already been deleted ;)
+timeline.events.delete(id: "e41fdc5c-6a8d-4d85-addb-27b6f81666e9")
+# => false
+```
+
+## Events
+Timelines events are stored in an events class which acts as a nice wrapped to our timeline Event objects.
+
+```ruby
+# create new timeline
+timeline = OcarinaOfTime::Line.new
+
+# adding events is very straightforward
+timeline.events.add(label: "Example 1")
+# => OcarinaOfTime::Event:0x00000001fcd040.id
+timeline.events.add(label: "Example 2")
+# => OcarinaOfTime::Event:0x00000001cabce0.id
+
+# you can easily update events
+timeline.events.update(id: "2f6716b1-9a2f-46d2-8bcf-4db0212032f1", value: 1)
+
+# you can easily delete events
+timelines.events.delete(id: "2f6716b1-9a2f-46d2-8bcf-4db0212032f1")
+
+# there's a nice little wrapped to sort_by
+timeline.events.by(oldest: true)
+# => OcarinaOfTime::Event:0x00000001cabce0, OcarinaOfTime::Event:0x00000001fcd040
+timeline.events.by(newest: true)
+# => OcarinaOfTime::Event:0x00000001fcd040, OcarinaOfTime::Event:0x00000001cabce0
+
+# you can also find events based on different attributes
+timeline.events.find(label: "Example 1")
+timeline.events.find(labels: ["Example 1", "Example 2"])
+timeline.events.find(event: timeline.events.all.first)
+timeline.events.find(date: Time.now.to_date)
+
+# you can also chain your find queries ( one option at a time )
+timeline.events.find(date: Time.now.to_date).find(label: "Example 1")
+
+# you can get a shortcut to all of the uniqe dates for each event
+timeline.events.dates
+# or a shortcut to all of the unique times for each event
+timeline.events.times
+# or you can get all of the unique labels
+timelines.events.labels
+# or you can get all of the unique ids
+timelines.events.ids
+# or you can get all of the unique tags
+timelines.events.tags
+
+# or if you don't want unique whatever, turn that off
+timelines.events.tags(unique: false)
+timelines.events.times(unique: false)
+```
+
+## Event
+Timeline Events are made up of serveral Event objects. An event object is made up of its unique ID number,
+its label, its tags ( as a set, unique ), the time of the event ( default to its creation time ), the time
+the event was created ( defaults to its creation time ) and a value -- which can be whatever you like, if you
+want to use that ( instead of just stuffing that data in tags ).
+
+```ruby
+# create a new timeline event
+event = OcarinaOfTime::Event.new
+
+# accessing event data ( reading ) with data shortcuts
+event.label
+# => false
+
+# accessing event data ( to change )
+event.data.label = "Example 1"
+
+event.label
+# => "Example 1" 
+
+# check for tags
+event.tags?
+# => false
+
+# add tags as an array or string
+tags = ["Cool", "Sick", "Awesome"]
+tag  = "Gnarly"
+event.add_tags(tags)
+event.add_tags(tag)
+
+# check for tags again
+event.tags?
+# => true
+
+# check out tags data
+event.tags
+# => Set: {"Cool", "Sick", "Awesome", "Gnarly"}
+
+# add the same event to two different timelines
+timeline1 = OcarinaOfTime::Line.new 
+timeline2 = OcarinaOfTime::Line.new 
+timeline1.events.add(event: event)
+# => "bb2aa0a0-68ee-469c-808b-875c7494a3c4"
+timeline2.events.add(event: event)
+# => "bb2aa0a0-68ee-469c-808b-875c7494a3c4"
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ocarina_of_time"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/debug.rb

@@ -0,0 +1,5 @@
+$: << File.expand_path("../../lib", __FILE__)
+require "ocarina_of_time"
+require "pry"
+
+binding.pry

data/lib/ocarina_of_time.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+# This file is part of Ocarina of Time 
+# See https://github.com/picatz/ocarina_of_time for more information
+# Copyright (C) 2017 Kent 'picat' Gruber
+# This program is published under MIT license.
+
+# TODO: Fix inline documentation.
+
+require "ocarina_of_time/version"
+require "ocarina_of_time/timeline"
+require "ocarina_of_time/event"
+require "ocarina_of_time/events"
+
+require 'set'
+require 'date'
+require 'time'
+require 'ostruct'
+require 'securerandom'
+
+# The Ocarina of Time is a ruby gem to manage timelines.
+# @author Kent 'picat' Gruber 
+module OcarinaOfTime
+# Easter Egg:
+#                                     /@
+#                     __        __   /\/
+#                    /==\      /  \_/\/   
+#                  /======\    \/\__ \__
+#                /==/\  /\==\    /\_|__ \
+#             /==/    ||    \=\ / / / /_/
+#           /=/    /\ || /\   \=\/ /     
+#        /===/   /   \||/   \   \===\
+#      /===/   /_________________ \===\
+#   /====/   / |                /  \====\
+# /====/   /   |  _________    /  \   \===\    THE LEGEND OF 
+# /==/   /     | /   /  \ / / /  __________\_____      ______       ___
+#|===| /       |/   /____/ / /   \   _____ |\   /      \   _ \      \  \
+# \==\             /\   / / /     | |  /= \| | |        | | \ \     / _ \
+# \===\__    \    /  \ / / /   /  | | /===/  | |        | |  \ \   / / \ \
+#   \==\ \    \\ /____/   /_\ //  | |_____/| | |        | |   | | / /___\ \
+#   \===\ \   \\\\\\\/   /////// /|  _____ | | |        | |   | | |  ___  |
+#     \==\/     \\\\/ / //////   \| |/==/ \| | |        | |   | | | /   \ |
+#     \==\     _ \\/ / /////    _ | |==/     | |        | |  / /  | |   | |
+#       \==\  / \ / / ///      /|\| |_____/| | |_____/| | |_/ /   | |   | |
+#       \==\ /   / / /________/ |/_________|/_________|/_____/   /___\ /___\ ゼルダの伝説
+#         \==\  /               | /==/
+#         \=\  /________________|/=/    OCARINA OF TIME
+#           \==\     _____     /==/ 
+#          / \===\   \   /   /===/
+#         / / /\===\  \_/  /===/
+#        / / /   \====\ /====/
+#       / / /      \===|===/
+#       |/_/         \===/
+#                      =
+# credit : http://www.ascii-code.com/ascii-art/video-games/zelda.php
+#
+end

data/lib/ocarina_of_time/event.rb

@@ -0,0 +1,64 @@
+module OcarinaOfTime
+
+  Struct.new("EventData", :id, :label, :tags, :time, :created, :value)
+  
+  class Event 
+    
+    attr_reader :data
+      
+    def initialize(args={})
+      @data = Struct::EventData.new 
+      @data.id = SecureRandom.uuid
+      @data.label = args[:label] || false
+      @data.value = args[:value] || false
+      @data.tags = Set.new
+      creation_time = Time.now
+      @data.time = args[:time] || creation_time 
+      @data.created = args[:created] || creation_time 
+      if args[:tags]
+        add_tags(args[:tags])
+      end
+    end
+
+    def id
+      @data.id
+    end
+
+    def label
+      @data.label
+    end
+    
+    def time 
+      @data.time
+    end
+    
+    def created
+      @data.created
+    end
+  
+    def time?
+      @data.tags.time ? true : false 
+    end
+
+    def tags
+      @data.tags.to_a
+    end
+
+    def tags?
+      @data.tags.empty? ? false : true
+    end
+
+    def add_tags(tags)
+      if tags.is_a? Array
+        tags.each do |tag|
+          @data.tags << tag
+        end
+      elsif tags.is_a? String
+        @data.tags << tags
+      end
+    end
+
+
+  end
+
+end

data/lib/ocarina_of_time/events.rb

@@ -0,0 +1,193 @@
+module OcarinaOfTime
+
+  class Events
+    
+    attr_reader :all
+      
+    def initialize
+      @all = [] 
+    end
+
+    def by(args={})
+      results = []
+      if args[:newest]
+        @all.each.sort_by { |e| e.time }.each do |event|
+          results << event
+        end
+      elsif args[:oldest]
+        @all.each.sort_by { |e| e.time }.reverse.each do |event|
+          results << event
+        end
+      else
+        @all
+      end
+      results.empty? ? false : results
+    end
+  
+    def add(args={})
+      if args[:event]
+        @all << args[:event]
+        return args[:event].id
+      end
+      event = Event.new
+      event.data.label = args[:label] || false
+      event.add_tags(args[:tags]) if args[:tags]
+      event.data.time = args[:time] if args[:time] 
+      @all << event
+      event.id
+    end
+
+    def delete(args={})
+      if args[:id]
+        @all.delete_if { |e| e.id == args[:id] }
+      elsif args[:event]
+        @all.delete_if { |e| e == args[:event] }
+      else
+        return false
+      end
+      true
+    end
+    
+    def update(args={})
+      if args[:id]
+        @all.each do |event|
+          if event.id == args[:id]
+            event.add_tags(args[:tags]) if args[:tags]
+            event.data.label = args[:label] if args[:label]
+            event.data.created = args[:created] if args[:created]
+            event.data.value = args[:value] if args[:value]
+          end
+        end
+      elsif args[:label]
+        @all.each do |event|
+          if event.label == args[:label]
+            event.add_tags(args[:tags]) if args[:tags]
+            event.data.label = args[:label] if args[:label]
+            event.data.created = args[:created] if args[:created]
+            event.data.value = args[:value] if args[:value]
+          end
+        end
+      elsif args[:tag]
+        @all.each do |event|
+          if event.tags.include?(args[:tag])
+            event.add_tags(args[:tags]) if args[:tags]
+            event.data.label = args[:label] if args[:label]
+            event.data.created = args[:created] if args[:created]
+            event.data.value = args[:value] if args[:value]
+          end
+        end
+      elsif args[:date]
+        @all.each do |event|
+          if event.time.to_date == args[:date]
+            event.add_tags(args[:tags]) if args[:tags]
+            event.data.label = args[:label] if args[:label]
+            event.data.created = args[:created] if args[:created]
+            event.data.value = args[:value] if args[:value]
+          end
+        end
+      elsif args[:time]
+        @all.each do |event|
+          if event.time == args[:time]
+            event.add_tags(args[:tags]) if args[:tags]
+            event.data.label = args[:label] if args[:label]
+            event.data.created = args[:created] if args[:created]
+            event.data.value = args[:value] if args[:value]
+          end
+        end
+      end
+    end
+
+    def find(args={})
+      results = Events.new
+      if args[:id]
+        @all.each { |e| results.all << e if e.id == args[:id] }
+      elsif args[:time]
+        @all.each { |e| results.all << e if e.time == args[:time] }
+      elsif args[:date]
+        @all.each { |e| results.all << e if e.time.to_date == args[:date] }
+      elsif args[:event]
+        @all.each { |e| results.all << e if e == args[:event] }
+      elsif args[:label]
+        @all.each { |e| results.all << e if e.label == args[:label] }
+      elsif args[:labels]
+        args[:labels].each do |label|
+          @all.each { |e| results.all << e if e.label == label }
+        end
+      elsif args[:tags]
+        args[:tags].each do |tag|
+          @all.each { |e| results.all << e if e.tags.include?(tag) }
+        end
+      elsif args[:tag]
+        @all.each { |e| results.all << e if e.tag == args[:tag] }
+      else
+        return false
+      end
+      results
+    end
+
+    def ids(args={unique: true})
+      if args[:unique]
+        ids = Set.new
+      else
+        ids = []
+      end
+      @all.each { |e| ids << e.id } 
+      ids.to_a
+    end
+    
+    def times(args={unique: true}) 
+      if args[:unique]
+        times = Set.new
+      else
+        times = []
+      end
+      @all.each { |e| times << e.time } 
+      times.to_a
+    end
+
+    def dates(args={unique: true})
+      if args[:unique]
+        dates = Set.new
+      else
+        dates = []
+      end
+      @all.each { |e| dates << e.time.to_date }
+      dates.to_a
+    end
+
+    def tags(args={unique: true})
+      if args[:unique]
+        tags = Set.new
+      else
+        tags = []
+      end
+      @all.each do |e| 
+        e.tags.to_a.each { |t| tags << t }
+      end
+      tags.to_a
+    end
+
+    def labels(args={unique: true})
+      if args[:unique]
+        labels = Set.new
+      else
+        labels = []
+      end
+      @all.each { |e| labels << e.label }
+      labels.to_a
+    end
+    
+    def values(args={unique: true})
+      if args[:unique]
+        values = Set.new
+      else
+        values = []
+      end
+      @all.each { |e| values << e.value }
+      labels.to_a
+    end
+
+
+  end
+
+end

data/lib/ocarina_of_time/timeline.rb

@@ -0,0 +1,243 @@
+module OcarinaOfTime
+
+  # Respresent the logic of a Timeline. 
+  # @author Kent 'picat' Gruber 
+  class Timeline
+
+    attr_accessor :beginning
+    attr_accessor :ending
+    attr_accessor :events
+
+    # Create a new **Timeline** object.
+    #
+    # @param [Hash] args arguments for method
+    # @option args [Time] :begin beginning point in time (default: +Time.now+)
+    # @option args [Time] :end ending point in time (default: false)
+    # @return [void]
+    def initialize(args={})
+      @beginning = args[:begin] || Time.now
+      @ending    = args[:end]   || false
+      @flex      = false # have a rigid timeline
+      @events    = Events.new
+    end
+
+    # Turn on a flexible timeline, where events will change the potential
+    # range of the timeline. If a beginning is set, an unflexible timeline
+    # will not allow any new events to be set before that time. A flexible timeline
+    # would set the newest ending if the event is before the current one. The same logic
+    # applies to an ending time which may or may not be set. Meaning, an unflexible timeline
+    # makes it very easy to grow ( by moving forward in time ) if there is no ending set.
+    def flex(on = true)
+      on ? @flex = true : @flex = false
+    end
+
+    # Check if the Timeline is flexible or not.
+    #
+    # @return[Boolean] 
+    def flex?
+      @flex ? true : false
+    end
+
+    # Check if there's currently a end of time
+    # associated with the timeline object.
+    # 
+    # @return[Boolean] 
+    def ending?
+      @ending ? true : false
+    end
+
+    # Check if there's currently a beginning of time
+    # associated with the timeline object.
+    # 
+    # @return[Boolean] 
+    def beginning?
+      @beginning ? true : false
+    end
+
+    # Get the difference in time between +two+ points in +time+.
+    # 
+    # @param [Hash] args arguments for method
+    # @option args [Time] :begin beginning point in time
+    # @option args [Time] :end ending point in time
+    # @option args [Time] :seconds get difference in seconds ( default )
+    # @option args [Time] :minutes get difference in minutes 
+    # @option args [Time] :hours get difference in hours 
+    # @option args [Time] :days get difference in days 
+    # @option args [Time] :weeks get difference in weeks 
+    # @option args [Time] :years get difference in years 
+    # @option args [Time] :decades get difference in decades 
+    # @option args [Time] :centuries get difference in centuries 
+    # @return [Float] the difference between two points
+    # 
+    # == Example
+    #  # generate new timeline
+    #  timeline = OcarinaOfTime::Line.new
+    #  # get days between two times
+    #  timeline.time_between(end: Time.now+87654, days: true)
+    #  # => 1.0150320438273612
+    #  timeline.time_between(end: Time.now+8070654, days: true)
+    #  # => 93.41134454091606
+    #  timeline.time_between(end: Time.now+8070654, weeks: true)
+    #  # => 13.344522046096547
+    # 
+    # == Example
+    #  # generate new time line
+    #  time_line = OcarinaOfTime::Line.new
+    #  # set end of time ( default is Time.now for beginning )
+    #  time_line.end_of_time = Time.now+8070654
+    #  # get time between the two points in minutes
+    #  time_line.time_between(minutes: true)
+    #  # => 134511.16985055877
+    #  
+    def time_between(args={})
+      if args[:begin].is_a? Event
+        start = args[:begin].time
+      else
+        start = args[:begin] || @beginning
+      end
+      raise "unable to determine first (begin) point" unless start
+      if args[:end]
+        if args[:end].is_a? Event
+          stop = args[:end].time
+        else
+          stop = args[:end]
+        end
+      else
+        stop = @ending if @ending
+        raise "unable to determine second (end) point" unless stop
+      end
+      diff = stop - start
+      if args[:seconds]
+        return diff
+      elsif args[:minutes]
+        return diff / 60
+      elsif args[:hours]
+        return diff / 3600
+      elsif args[:days]
+        return diff / 86400
+      elsif args[:weeks]
+        return diff / 604800
+      elsif args[:years]
+        return diff / 31449600
+      elsif args[:decades]
+        return diff / 314496000 
+      elsif args[:centuries]
+        return diff / 3144960000 
+      else
+        return diff
+      end
+    end
+
+    # Get the days between +two+ points in +time+.
+    #
+    # @param [Hash] args arguments for method
+    # @option args [Time] :begin beginning point in time
+    # @option args [Time] :end ending point in time
+    # @return [Array<Date>] dates between two points in time
+    # 
+    # == Example
+    #  # generate new time line
+    #  time_line = OcarinaOfTime::Line.new
+    #  # get days between two times
+    #  time_line.days_between(begin: Time.now - 100000, end: Time.now)
+    #  # => [#<Date: 2017-02-19 ((2457804j,0s,0n),+0s,2299161j)>, #<Date: 2017-02-20 ((2457805j,0s,0n),+0s,2299161j)>] 
+    def days_between(args={})
+      start = args[:begin] || @beginning
+      if args[:end]
+        stop = args[:end]
+      else
+        stop = @ending if @ending
+      end
+      (start.to_date..stop.to_date).to_a
+    end
+
+    # Parse an array of dates to filter out for specifc days
+    # of the week ( Monday .. Sunday ).
+    #
+    # @param [Hash] arguments for method
+    # @option args [Array<Date>] :days array of dates to work with
+    # @option args [Boolean] :mondays get mondays
+    # @option args [Boolean] :tuesdays get tuesdays
+    # @option args [Boolean] :wednesdays get wednesdays
+    # @option args [Boolean] :thursdays get thursdays
+    # @option args [Boolean] :fridays get fridays 
+    # @option args [Boolean] :saturdays get saturdays 
+    # @option args [Boolean] :sundays get sundays 
+    # @option args [Array<Int>] :years get years
+    # @option args [Array<Int>] :months get months, represented as an int 
+    # @return [Array<Date>] parsed dates 
+    # 
+    # == Example
+    #  # generate new time line
+    #  time_line = OcarinaOfTime::Line.new
+    #  # get days between two times
+    #  days = time_line.days_between(begin: Time.now - 10000000, end: Time.now)
+    #  # parse days for mondays only
+    #  time_line.find_days(days: days, mondays: true)
+    #  # parse days for sundays only
+    #  time_line.find_days(days: days, sundays: true)
+    #  # parse days for wednesdays and fridays only
+    #  time_line.find_days(days: days, wednesdays: true, fridays: true)
+    def find_days(args={})
+      unless args[:days]
+        if @ending and @beginning
+          all_days = days_between 
+        else
+          raise "need to specify days to work with"
+        end
+      else
+        all_days = args[:days]
+      end
+      days = Set.new
+      all_days.each do |day|
+        days << day if day.monday?    and args[:mondays]
+        days << day if day.tuesday?   and args[:tuesdays]
+        days << day if day.wednesday? and args[:wednesdays]
+        days << day if day.thursday?  and args[:thursdays]
+        days << day if day.friday?    and args[:fridays]
+        days << day if day.saturday?  and args[:saturdays]
+        days << day if day.sunday?    and args[:sundays]
+      end
+      days.to_a
+    end
+
+    # Parse an array of dates to filter out for specifc dates
+    # that match a specific yeay ( 1970, 1994, 2017 .. ect ).
+    #
+    # @param [Hash] arguments for method
+    # @option args [Array<Date>] :days array of dates to work with
+    # @option args [Array, Integer] :years get specific years 
+    # @return [Array<Date>] parsed years 
+    # 
+    # == Example
+    #  # generate new time line
+    #  time_line = OcarinaOfTime::Line.new
+    #  time_line.end_of_time = Time.now+8070654
+    #  # parse days for the year 2017 
+    #  time_line.find_years(years: 2017)
+    #  # parse days for the year 2016 or 2017 
+    #  time_line.find_years(years: [2016, 2017])
+    def find_years(args={})
+      unless args[:days]
+        if @ending and @beginning
+          all_days = days_between 
+        else
+          raise "need to specify days to work with"
+        end
+      else
+        all_days = args[:days]
+      end
+      days = Set.new
+      all_days.each do |day|
+        if args[:years]
+          if args[:years].is_a? Array
+            days << day if args[:years].include? day.year 
+          elsif args[:years].is_a? Integer
+            days << day if args[:years] == day.year 
+          end
+        end
+      end
+      days.to_a
+    end
+  end
+end

data/lib/ocarina_of_time/version.rb

@@ -0,0 +1,3 @@
+module OcarinaOfTime
+  VERSION = "1.0.0"
+end

data/ocarina_of_time.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ocarina_of_time/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ocarina_of_time"
+  spec.version       = OcarinaOfTime::VERSION
+  spec.authors       = ["Kent Gruber"]
+  spec.email         = ["kgruber1@emich.edu"]
+
+  spec.summary       = %q{The Ocarina of Time is a ruby gem to manage timelines.}
+  spec.description   = %q{The Ocarina of Time is a ruby gem to manage timelines through a simple API to contrsuct timelines and manage the events that happen during the liftime of a timeline.}
+  spec.homepage      = "https://github.com/picatz/Ocarina-of-Time"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "bin"
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: ocarina_of_time
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kent Gruber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: The Ocarina of Time is a ruby gem to manage timelines through a simple
+  API to contrsuct timelines and manage the events that happen during the liftime
+  of a timeline.
+email:
+- kgruber1@emich.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/debug.rb
+- lib/ocarina_of_time.rb
+- lib/ocarina_of_time/event.rb
+- lib/ocarina_of_time/events.rb
+- lib/ocarina_of_time/timeline.rb
+- lib/ocarina_of_time/version.rb
+- ocarina_of_time.gemspec
+homepage: https://github.com/picatz/Ocarina-of-Time
+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.6.8
+signing_key: 
+specification_version: 4
+summary: The Ocarina of Time is a ruby gem to manage timelines.
+test_files: []