timeline-manager 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8da990d4583655335ad676d2a17af7a6474f1a14c49707c313c7089ad0af3fea
+  data.tar.gz: d817ddc51240341c721631ea9203d9f13a73f1d36e8b453d35f435e405393a0c
+SHA512:
+  metadata.gz: a07e9f3627aed54ffe1c952ed061b82c55add602d6ef08fda4f3449bb77c07e571aa0c049e4d6781d87f7b0d8aae846e45573f6ce6478e95bad7c9481e559810
+  data.tar.gz: 44d7b7ecd229e12269cd507f9d7389ea9f8a23a66099b13100e9511f110c2618d82fd10d3a617d389238e0f27d988a1dbd1eaff194f06ccc976a244cdc105745

data/lib/EventedArray.rb

@@ -0,0 +1,25 @@
+class EventedArray < Array
+  # The calling context knows whether an element has been
+  # created, deleted or updated.
+  # This class is to be used in an append-only environment.
+
+  def initialize(post_delete, post_create, post_update)
+    @post_delete = post_delete
+    @post_create = post_create
+    @post_update = post_update
+  end
+
+  def delete(data)
+    @post_destroy.call(data)
+  end
+
+  def create(data)
+    self << data
+    @post_create.call(data)
+  end
+
+  def update(data)
+    self << data
+    @post_update.call(data)
+  end
+end

data/lib/TimeObj.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/object'
+
+class TimeObj
+	# An interface to deal with passed-in time objects which
+	# may have a variety of interfaces. 
+
+	include Comparable
+
+	attr_reader :data
+	attr_reader :start_method
+	attr_reader :end_method
+
+	def initialize(data, start_method=:start, end_method=:end)
+		if data.respond_to? :each
+			@data = data
+		else
+			@data = [data]
+		end
+		if @data.class == Range || @data.class == Array
+			start_method = :first
+			end_method = :last
+		end
+		@start_method = start_method
+		@end_method = end_method
+	end
+
+	def <=>(other)
+		@data <=> other.data
+	end
+
+	def start
+		@data[@start_method]
+	end
+
+	def end
+		@data[@end_method]
+	end
+
+	def merge(params)
+		if @data.respond_to? :attributes
+			return @data.class.new(@data.attributes.merge(params))
+		elsif @data.respond_to? :merge
+			return @data.merge(params)
+		end
+		raise ArgumentError.new('Objects that are represented as times must respond to :attributes or :merge.')
+	end
+
+	def duration
+		self.end - start
+	end
+end

data/lib/timeline-manager.rb

@@ -0,0 +1,132 @@
+require 'active_support/core_ext/object'
+require 'TimeObj'
+require 'EventedArray'
+
+module TimelineManager
+	class Timeline
+
+		def initialize(times=[], time_diff: Proc.new { 1.day }, start_method: :start,
+                  end_method: :end, post_delete: Proc.new{}, post_create: Proc.new{},
+                  post_update: Proc.new{})
+			@times = times.map { |t| t.class == TimeObj ? t : TimeObj.new(t, start_method, end_method) }
+			@time_diff = time_diff
+			@start_method = start_method
+			@end_method = end_method
+			@post_delete = post_delete
+			@post_create = post_create
+      @post_update = post_update
+		end
+
+    def to_s
+      data
+    end
+
+    def inspect
+      "TimelineManager::Timeline##{self.object_id} #{to_s}"
+    end
+
+		def data
+			@times.map { |t| t.data }
+		end
+
+		def insert(time, time_diff: Proc.new { 1.day }, start_method: :start,
+                  end_method: :end, post_delete: nil, post_create: nil,
+                  post_update: nil)
+			# Produce a new Timeline where time's start through end is unique in @times.
+			time = TimeObj.new(time, start_method, end_method)
+			new_times = EventedArray.new((post_delete || @post_delete), (post_create || @post_create), (post_update || @post_update))
+			@times.each do |t|
+	      if t.start >= time.start && t.end <= time.end
+	        # The new time covers the old one completely; remove it.
+	        new_times.delete t
+	      elsif t.start < time.start && t.end > time.end
+	        # The new time splits the old one in half.
+	        new_times.update t.merge({"#{t.end_method}": time.start - time_diff.call})
+	        new_times.update t.merge({"#{t.start_method}": time.end + time_diff.call})
+	      elsif t.start < time.start
+	        # The new time cuts off the old time's end.
+	        new_times.update t.merge({"#{t.end_method}": time.start - time_diff.call })
+	      else
+	        # The new time cuts off the old time's beginning.
+	        new_times.update t.merge({"#{t.start_method}": time.end + time_diff.call })
+	      end
+	    end
+	    new_times.create time
+	    Timeline.new(new_times, time_diff: @time_diff, start_method: @start_method, 
+        end_method: @end_method, post_delete: @post_delete, post_create: @post_create, 
+        post_update: @post_update)
+		end
+
+		def overlap(time, time_diff: Proc.new { 1.day }, start_method: :start,
+                  end_method: :end, post_delete: nil, post_create: nil,
+                  post_update: nil)
+			# Beginning and end overlap, but middle is replaced. 
+			time = TimeObj.new(time, start_method, end_method)
+      new_times = EventedArray.new((post_delete || @post_delete), (post_create || @post_create), (post_update || @post_update))
+			@times.each do |t|
+		    if t.start > time.start && t.end < time.end
+		      # The new time covers the old one completely; remove it.
+		      new_times.delete t
+		    elsif t.start <= time.start && t.end >= time.end
+		      # The new time splits the old one in half.
+		      if time.duration > time_diff.call
+		        # The new time is more than one time_diff long
+		        new_times.update t.merge({"#{t.start_method}": time.end})
+		        new_times.update t.merge({"#{t.end_method}": time.start})
+		      end
+		    elsif t.start < time.start
+		      # The new time cuts off the old time's end.
+		      new_times.update t.merge({"#{t.end_method}": time.start})
+		    elsif t.start == time.start && time.end >= t.end
+		      # The new time starts on the old time's start, but the new time continues past the time's end
+		      new_times.update t.merge({"#{t.end_method}": t.start})
+		    else
+		      # The new time cuts off the old time's beginning.
+		      new_times.update t.merge({"#{t.start_method}": time.end})
+		    end
+		  end
+		  new_times.create time
+	    Timeline.new(new_times, time_diff: @time_diff, start_method: @start_method, 
+        end_method: @end_method, post_delete: @post_delete, post_create: @post_create, 
+        post_update: @post_update)
+		end
+
+		def overlay(time, start_method: :start, end_method: :end, post_delete: nil)
+			# Simply add the new time to the time line; allows complete overlap.
+			new_times = EventedArray.new((post_delete || @post_delete), (post_create || @post_create), (post_update || @post_update))
+      new_times << @times
+      new_times.create time
+	    Timeline.new(new_times, time_diff: time_diff, start_method: @start_method, 
+        end_method: @end_method, post_delete: @post_delete, post_create: @post_create, 
+        post_update: @post_update)
+		end
+
+		def split(date, time_diff: Proc.new { 1.day }, post_update: nil)
+			# Splits timelines in half given a point in time.
+			time = TimeObj.new({start: date, end: date + time_diff.call})
+      new_times = EventedArray.new(@post_delete, @post_create, (post_update || @post_update))
+			@times.each do |t|
+		    if t.start > time.start && t.end < time.end
+		      # The new time covers the old one completely.
+		      new_times << t
+		    elsif t.start <= time.start && t.end >= time.end
+		      # The new time splits the old one in half.
+	        new_times.update t.merge({"#{t.start_method}": time.end})
+	        new_times.update t.merge({"#{t.end_method}": time.start})
+		    elsif t.start < time.start
+		      # The new time cuts off the old time's end.
+		      new_times.update t.merge({"#{t.end_method}": time.start})
+		    elsif t.start == time.start && time.end >= t.end
+		      # The new time starts on the old time's start, but the new time continues past the time's end
+		      new_times.update t.merge({"#{t.end_method}": t.start})
+		    else
+		      # The new time cuts off the old time's beginning.
+		      new_times.update t.merge({"#{t.start_method}": time.end})
+		    end
+		  end
+	    Timeline.new(new_times, time_diff: @time_diff, start_method: @start_method, 
+        end_method: @end_method, post_delete: @post_delete, post_create: @post_create, 
+        post_update: @post_update)
+		end
+	end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: timeline-manager
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tyler Brothers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-24 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email: tylerbrothers1@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/EventedArray.rb
+- lib/TimeObj.rb
+- lib/timeline-manager.rb
+homepage: https://github.com/possibly/timeline-manager
+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.7.7
+signing_key: 
+specification_version: 4
+summary: Timeline Manager helps order and transform grouped temporal data
+test_files: []