time_span 0.0.1.alpha03 → 0.0.1.alpha04

data/lib/time_span.rb

@@ -1,8 +1,8 @@
 #require "time_span/version"
-require 'date'
 
 module TimeSpan
-    class TimeSpan
+
+  class TimeSpan
 
     attr_accessor :starts, :ends     # RelativeTime objects
 
@@ -11,6 +11,7 @@ module TimeSpan
     ##################################
 
     def initialize(starting_at, ending_at)
+      raise "Cannot make a span unless both points are on the same timeline" unless  starting_at.colinear_with?(ending_at)
       self.starts = starting_at
       self.ends   = ending_at
       starting_at.kind_of?(RelativeTime) && ending_at.kind_of?(RelativeTime)
@@ -85,6 +86,10 @@ module TimeSpan
       ends_with?(b) && starts_with?(b)
     end
 
+    def != (b)
+      !end_with(b) || !starts_with(b)
+    end
+
     def < (b)
       ends_before_other_starts?(b)
     end
@@ -110,8 +115,147 @@ module TimeSpan
     end
 
   end
+  #
+  class TimeLine <  Array
+
+    attr_accessor :line, :indices_of, :name
+
+    def to_s
+      name.to_s
+    end
+
+    def initialize(name="")
+      @name = name
+      @line = []
+      @indices_of = {}
+    end
+
+    def position_of(obj)
+      @indices_of[obj]
+    end
+
+    def append(obj)
+      insert_at(@line.size, obj)
+    end
+
+    def increase_after(pos, by=1)
+      @indices_of.each_key do |key|
+        @indices_of[key] += by if (@indices_of[key] >= pos)
+      end
+    end
+
+    def append_to_next(relative_obj, obj, relative=1)
+      insert_at(position_of(relative_obj)+relative, obj)
+    end
+
+    def insert_before_next(relative_obj, obj, relative_offset=1)
+      relative_position = position_of(relative_obj)
+      increase_after(relative_position + relative_offset, relative_offset)
+      @line[relative_position + relative_offset,0] = nil
+      insert_at(relative_position+relative_offset, obj)
+    end
+
+    ## needs work for RelativeTime objects
+    def insert_at(pos, obj)
+
+      raise "can only add a time to its own timeline" unless obj.timeline.equal? self
+      if @line[pos].nil?
+        @line[pos] = [obj]
+        @indices_of[obj] = pos
+      else
+        op = @line[pos].kind_of?(Array) ? '<<'  : '='
+        @line[pos].send(op.to_sym, obj) unless @line[pos].include?(obj)  # no dupliates
+        @indices_of[obj] = pos                                           # dup overwrites
+      end
+    end
+
+    def remove(obj)
+      # cannot remove [] or the @indices_of will be wrong
+      # call to #compress to remove the extra []s
+      pos =  position_of(obj)
+
+      if pos                        # do nothing if it isn't there'
+        @line[pos].delete(obj)
+        @indices_of.delete(obj)
+      end
+
+    end
+
+    ## removes all [] elements, and decrements accordingly the @indices_of
+    ##  ideally this should be transactional
+
+    def compress!
+
+      mod_level = 0
+      offsets = []
+      0.upto(line.size-1) do |i|
+        mod_level -= 1 if @line[i].empty?
+        offsets << mod_level
+      end
+
+      ## poor man's transaction.  Don't do directly on indices_of so less chance of interruption
+      indices = indices_of
+
+      ## refactor to use increase_after
+      indices.each_key do |key|
+        indices[key] = indices[key] + offsets[indices[key]]
+      end
+
+      indices_of = indices
+      @line.delete([])
+    end
+
+  end
+
+  ###########################################################################################
+  #                                                                                         #
+  # A relative time must be able to be have equal times                                     #
+  # implemented as an Array of Arrays; all elements of the 'subarray' are equal in time,    #
+  # otherwise, the time relationship are based on position in the main array                #
+  #                                                                                         #
+  # diff cannot be done, it makes no sense, due to the fuzziness                            #
+  #                                                                                         #
+  #  RelativeTime must be within a TimeLine                                                 #
+  ###########################################################################################
+
+  class RelativeTime
+
+    attr_accessor  :timeline, :reference_to    # reference_to should respond_to? :to_s
+
+    # create a realtive time *within a timeline*  after position
+    def initialize  tline, ref
+       @timeline= tline
+       @reference_to= ref
+    end
+
+    def to_s
+      reference_to.to_s
+    end
+
+    ## any method on fixnum with 1 RelativeTime param can be in the list below
+    %w{< <= == != >= >}.each{ |meth|
+      self.send(:define_method, meth) {|b|
+        raise "can only compare to other times on the same timeline." unless valid_and_comparable_with?(b)     # can NOT compare across TimeLines
+        self.timeline.position_of(self).send(meth, b.timeline.position_of(b))
+      }
+    }
+
+    def positioned?
+      self.timeline.indices_of.keys.include?(self)
+    end
+
+    def colinear_with?(b)
+      self.timeline.equal?(b.timeline)
+    end
+
+
+    protected
+
+    def valid_and_comparable_with?(b)
+      !self.timeline.nil? && !b.timeline.nil?  &&  colinear_with?(b)
+    end
+
 
-  # first implementation is just as DateTime; later add fuzzy  time
-  class RelativeTime  < ::DateTime
   end
+
 end

data/lib/time_span/version.rb

@@ -1,3 +1,3 @@
 module TimeSpan
-  VERSION = "0.0.1.alpha03"
+  VERSION = "0.0.1.alpha04"
 end

data/spec/time_span/time_span_spec.rb

@@ -2,82 +2,222 @@ require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
 
 describe "TimeSpan" do
 
-  context "TimeSpan" do
+  let(:timeline) do
+    TimeSpan::TimeLine.new  "test timeline"
+  end
+
+  let (:time_a) do
+    TimeSpan::RelativeTime.new timeline, "Some timepoint a"
+  end
+
+  let (:time_b) do
+    TimeSpan::RelativeTime.new timeline, "Some timepoint b"
+  end
+
+  let (:time_c) do
+    TimeSpan::RelativeTime.new timeline, "Some timepoint c"
+  end
+
+  let (:time_d) do
+    TimeSpan::RelativeTime.new timeline, "Some timepoint d"
+  end
+
+  before(:each) do
+    timeline.append time_a
+    timeline.append time_b
+    timeline.append time_c
+  end
+
+  let (:time_span) do
+    TimeSpan::TimeSpan.new(time_a, time_c)
+  end
+
+  context "TimeSpan::TimeLine" do
 
     context "instance methods" do
 
-      let (:alpha_start) do
-        TimeSpan::RelativeTime.parse("Jan 1, 2007")
+      context "insertion"  do
+
+        it "inserts a TimeSpan::RelativeTime into the timeline." do
+          timeline.line.should_not be_empty
+        end
+
+        it 'populates the indices_of as well' do
+           timeline.indices_of.should_not be_empty
+        end
+
+        it "won't insert into the wrong timeline" do
+          timeline_b = TimeSpan::TimeLine.new "Another Timeline"
+          lambda {
+          timeline_b.append(time_a) }.should raise_error RuntimeError
+        end
+
+        it "populates the index hash"  do
+          timeline.indices_of.should_not be_empty
+        end
+
+        it "appends to the next element if it exists" do
+          timeline.append_to_next time_a, time_d
+          timeline.line.should  ==  [[time_a], [time_b, time_d], [time_c]]
+        end
+
+        it "inserts after and creates if element does not exist" do
+          timeline.append_to_next time_c, time_d
+          timeline.line.should ==  [[time_a], [time_b], [time_c], [time_d]]
+        end
+
+        it "inserts after a given time with insert_next" do
+          timeline.insert_before_next time_a, time_d
+          timeline.line.should ==  [[time_a], [time_d], [time_b], [time_c]]
+        end
+
+        it "should adjust the indices when inserting next" do
+          timeline.insert_before_next time_a, time_d
+          timeline.indices_of[time_b].should == 2
+        end
+
       end
 
-      let (:alpha_end) do
-       alpha_start + 2000
+      context "appending" do
+
+        it "appends to the timeline" do
+          timeline.append time_d
+          timeline.indices_of[time_d].should == 3
+        end
+
+        it "has only one RelativeTime after appending to an empty timeline" do
+          timeline.append time_d
+          timeline.line.size.should be(4)
+        end
+
       end
 
+      context "finding" do
+
+        it "finds an inserted time_span" do
+          timeline.position_of(time_b).should == 1
+        end
 
-      let (:alpha) do
-        TimeSpan::TimeSpan.new(alpha_start, alpha_end)
       end
 
-      context "single time point comparators" do
+      context "removal" do
 
-        context "same ends time, alpha starts before beta" do
+        it "removes the content with #remove(obj)"  do
+          timeline.remove time_b
+          timeline.position_of(time_b).should be_nil
+        end
 
-          let (:beta_start) do
-            TimeSpan::RelativeTime.parse("Jan 1, 2008")
-          end
+        it "removes from the index as well" do
+          timeline.remove time_b
+          timeline.indices_of[time_b].should be_nil
+        end
 
-          let (:beta) do
-            TimeSpan::TimeSpan.new(beta_start, alpha_end)
-          end
+        it "does nothing when asked to remove a non-existent object" do
+          lambda { timeline.remove(time_d)}.should_not change(timeline, :indices_of)
+        end
+
+      end
+
+      context "compression" do
+
+        it "returns identity when compressing full timeline" do
+          timeline.compress!
+          timeline.line.size.should be 3
+        end
+
+        it "does not remove from index position when not compressing" do
+          timeline.remove time_b
+          timeline.indices_of[time_c].should == 2
+        end
 
-          context "alpha" do
+        it "removes from the index when compressing" do
+          timeline.remove time_b
+          timeline.compress!
+          timeline.indices_of[time_c].should == 1
+        end
 
-            it "starts before beta" do
-              alpha.should be_starts_before(beta)
-            end
+        it "removes content positions from the timeline when compressing" do
+          timeline.remove time_b
+          timeline.compress!
+          timeline.line.should == [[time_a], [time_c]]
+        end
 
+      end
+
+      context "finding position" do
+
+        it "returns the position of a RelativeTime" do
+          timeline.position_of(time_b).should == 1
+        end
+
+      end
+
+    end
+
+  end
 
-            it "ends with beta" do
-              alpha.should be_ends_with(beta)
-            end
+  context "TimeSpan::TimeSpan" do
 
+    context "instance methods" do
+
+      context "creation" do
+
+        it "should not allow creation when RelativeTime elements which are not on the same TimeLine" do
+          other_timeline = TimeSpan::TimeLine.new "another timeline"
+          time_other = TimeSpan::RelativeTime.new other_timeline, "Time on other timeline"
+          lambda {
+            TimeSpan::TimeSpan.new(time_a, time_other)
+          }.should raise_error
+        end
+
+      end
+
+      context "single time point comparators" do
+
+        context "same end time, time_span starts before other time_span" do
+
+          let (:time_span_2) do
+            TimeSpan::TimeSpan.new(time_b, time_c)
           end
 
-          context "alpha does not" do
+          it "start before other time_span" do
+            time_span.should be_starts_before(time_span_2)
+          end
 
-            it "start after beta" do
-              alpha.should_not be_starts_after(beta)
-            end
+          it "end with other time_span" do
+            time_span.should be_ends_with(time_span_2)
+          end
 
-            it "start with beta" do
-              alpha.should_not be_starts_with(beta)
-            end
+          it "not start after other time_span" do
+            time_span.should_not be_starts_after(time_span_2)
+          end
 
-            it "end before beta" do
-              alpha.should_not be_ends_before(beta)
-            end
+          it "not start with other time_span" do
+            time_span.should_not be_starts_with(time_span_2)
+          end
 
-            it "end after beta" do
-              alpha.should_not be_ends_after(beta)
-            end
+          it "not end before other time_span" do
+            time_span.should_not be_ends_before(time_span_2)
+          end
 
-            it "end before beta starts" do
-              alpha.should_not be_ends_before_other_starts(beta)
-            end
+          it "end after other time_span" do
+            time_span.should_not be_ends_after(time_span_2)
+          end
 
-            it "end as beta starts" do
-              alpha.should_not be_ends_as_other_starts(beta)
-            end
+          it "end before other time_span starts" do
+            time_span.should_not be_ends_before_other_starts(time_span_2)
+          end
 
-            it "start after beta ends" do
-              alpha.should_not be_starts_after_other_ends(beta)
-            end
+          it "end as other time_span starts" do
+            time_span.should_not be_ends_as_other_starts(time_span_2)
+          end
 
-            it "start as beta ends" do
-              alpha.should_not be_starts_as_other_ends(beta)
-            end
+          it "start after other time_span ends" do
+            time_span.should_not be_starts_after_other_ends(time_span_2)
+          end
 
+          it "start as other time_span ends" do
+            time_span.should_not be_starts_as_other_ends(time_span_2)
           end
 
         end
@@ -86,63 +226,65 @@ describe "TimeSpan" do
 
       context "time span comparators" do
 
-        let (:beta_earliest) do
-          alpha_start - 1000
+        let (:time_d) do
+          TimeSpan::RelativeTime.new timeline, "Some timepoint d"
         end
 
-        let (:beta_before_alpha_starts) do
-          alpha_start - 500
+        let (:time_e) do
+          TimeSpan::RelativeTime.new timeline, "Some timepoint e"
         end
 
-        let (:beta_after_alpha_starts) do
-          alpha_start + 500
+        before(:each) do
+          timeline.append time_a
+          timeline.append time_b
+          timeline.append time_c
+          timeline.append time_d
+          timeline.append time_e
         end
 
-        let (:beta_before_alpha_ends) do
-          alpha_start + 1000
+        let (:time_span_mid) do
+          TimeSpan::TimeSpan.new(time_b, time_c)
         end
 
-        let (:beta_right_after_alpha_ends) do
-          alpha_end + 500
+        let(:time_span_all) do
+          TimeSpan::TimeSpan.new(time_a, time_e)
         end
 
-        let (:beta_last) do
-          alpha_end + 1000
+        let (:time_span_last) do
+          TimeSpan::TimeSpan.new(time_d, time_e)
         end
 
         it "identical start and end times should return == as true" do
-          beta = TimeSpan::TimeSpan.new(alpha_start, alpha_end)
-          alpha.should == beta
+          time_span_3 = TimeSpan::TimeSpan.new(time_a, time_c)
+          time_span.should == time_span_3
         end
 
-        it "alpha ends before beta starts, should return alpha < beta" do
-          beta = TimeSpan::TimeSpan.new(beta_right_after_alpha_ends, beta_last)
-          alpha.should < beta
+        it "any differences should return not equal" do
+          time_span_all.should_not == time_span               # end times differ
         end
 
-        it "alpha starts after beta ends, should return alpha > beta" do
-          beta = TimeSpan::TimeSpan.new(beta_earliest, beta_before_alpha_starts)
-          alpha.should > beta
+        it "time_span ends before time_span_last starts, should return time_span < time_span_last" do
+          time_span.should < time_span_last
         end
 
-        it "alpha starting after and ending before beta should be contained inside beta" do
-          beta = TimeSpan::TimeSpan.new(beta_earliest, beta_last)
-          alpha.should be_contained_fully_inside(beta)
+        it "time_span starts after time_span_last ends, should return time_span_last > time_span" do
+          time_span_last.should > time_span
         end
 
-        it "alpha starting with beta but ending before, is contained inside" do
-          beta = TimeSpan::TimeSpan.new(alpha_start, beta_last)
-          alpha.should be_contained_inside(beta)
+        it "time_span starting after and ending before time_span_mid should be contained inside time_span_mid" do
+          time_span_mid.should be_contained_fully_inside(time_span_all)
         end
 
-        it "alpha starting before and ending after full contains beta" do
-          beta = TimeSpan::TimeSpan.new(beta_after_alpha_starts, beta_before_alpha_ends)
-          alpha.should be_contains_fully(beta)
+        it "time_span starting with time_span_all but ending before, is contained inside" do
+          time_span.should be_contained_inside(time_span_all)
         end
 
-        it "alpha starting before but ending with beta should contain beta" do
-          beta = TimeSpan::TimeSpan.new(beta_after_alpha_starts, alpha_end)
-          alpha.should be_contains(beta)
+        it "time_span starting before and ending after time_span_full contains time_span_mid" do
+          time_span_all.should be_contains_fully(time_span_mid)
+        end
+
+        it "time_span starting before but ending with time_span_mid should contain time_span_mmid" do
+          time_span.should be_contains(time_span_mid)
         end
 
       end
@@ -151,6 +293,35 @@ describe "TimeSpan" do
 
   end
 
+  context "TimeSpan::RelativeTime" do
+
+    context "instance methods" do
+
+      ## comparators make sense only in TimeLine context, not tested here.
 
+      let (:timeline) do
+        TimeSpan::TimeLine.new "Some timeline"
+      end
+
+      let (:time) do
+        TimeSpan::RelativeTime.new timeline, "time point"
+      end
+
+      it "returns a string if using '.to_s'" do
+        time.to_s.should == 'time point'
+      end
+
+      it "is not positioned if not appended" do
+        time.should_not be_positioned
+      end
+
+      it 'is positioned once appended.' do
+        timeline.append time
+        time.should be_positioned
+      end
+
+    end
+
+  end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: time_span
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha03
+  version: 0.0.1.alpha04
   prerelease: 6
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-31 00:00:00.000000000 Z
+date: 2012-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &79762560 !ruby/object:Gem::Requirement
+  requirement: &79260830 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *79762560
+  version_requirements: *79260830
 description: Time spans, including many comparators
 email:
 - craig.a.cook@gmail.com