timed 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91f02760afcbcaf91d29ddf7fe817fbc0ec7dcf5
-  data.tar.gz: b7220abee0fce727c26f6961ebbffbc737cc7eb2
+  metadata.gz: 51ecc6d39d16ae5d47b2b658519e10bf6eb16098
+  data.tar.gz: e6f32281f459d65b349774944625d7232c95654b
 SHA512:
-  metadata.gz: db98749f2945a92b8ae56e58bdeb08d05c4b417fe8e2d9fc627f9de9cf39becf99000189c9b32b3eda704299eb8ac045ab23ba5f42e96191744534559f828c4d
-  data.tar.gz: 076b4b45416d418b1554453f5a97b82c717a242cbff240c827111a527bb0ac24e74b822d03498be917a020f84e035fe4cdec325b8d44b44c8db9e49f96abf97e
+  metadata.gz: ceb78b7e82c7f1ab1de38cd7747a681261906d3b8517324a26245f899346cbbd749cec81e6bd54fdadf34d21b1ea0095d27ddf8c39148fc0693c3a5d95aa4901
+  data.tar.gz: d97ed62d7ca6e1c787749b824cdfd8c64790b8662020ba7cfde66b240a4e9dd9567476f968cc25be83412538871ac62247447eae2c23e9a7c11fafc2728ca4b2

data/README.md

@@ -1,5 +1,6 @@
 # Timed
 
+[![Gem Version](https://badge.fury.io/rb/timed.svg)](https://badge.fury.io/rb/timed)
 [![Build Status](https://travis-ci.org/seblindberg/ruby-timed.svg?branch=master)](https://travis-ci.org/seblindberg/ruby-timed)
 [![Coverage Status](https://coveralls.io/repos/github/seblindberg/ruby-timed/badge.svg?branch=master)](https://coveralls.io/github/seblindberg/ruby-timed?branch=master)
 [![Inline docs](http://inch-ci.org/github/seblindberg/ruby-timed.svg?branch=master)](http://inch-ci.org/github/seblindberg/ruby-timed)

data/lib/timed/item.rb

@@ -4,15 +4,22 @@ module Timed
   # The Timed Item is a Moment that can be chained to others to form a sequence.
   # Importantly, items in a sequence are guaranteed to be sequential and non
   # overlapping.
-  
+
   class Item < Linked::Item
     include Moment
+
     # The value field is used to store the timespan and shuold not be accessed
     # directly.
 
     protected :value
     private :value=
 
+    # Provide a more ideomatic accessor for the sequence that the item is part
+    # of.
+
+    alias sequence list
+    alias in_sequence? in_list?
+
     # Creates a new Timed Item from a timespan. A timespan is any object that
     # responds to #begin and #end with two numerical values. Note that the end
     # must occur after the start for the span to be valid.
@@ -22,9 +29,10 @@ module Timed
     #
     # timespan - object responding to #begin and #end.
     # end_at - if given, it togheter with the first argument will be used as the
-    #          begin and end time for the item
+    #          begin and end time for the item.
+    # sequence - optional sequence to add the item to.
 
-    def initialize(timespan, end_at = nil)
+    def initialize(timespan, end_at = nil, sequence: nil)
       if end_at
         begin_at = timespan
       else
@@ -35,34 +43,21 @@ module Timed
       raise TypeError unless begin_at.is_a?(Numeric) && end_at.is_a?(Numeric)
       raise ArgumentError if end_at < begin_at
 
-      super begin_at..end_at
+      super begin_at..end_at, list: sequence
     end
 
     # Returns the time when the item starts.
 
     def begin
-      value.begin
+      offset value.begin
     end
 
     # Returns the time when the item ends.
 
     def end
-      value.end
-    end
-
-    # Returns a new Item in the intersection
-    #
-    # other - object that implements both #begin and #end.
-
-    def intersect(other)
-      begin_at = self.begin >= other.begin ? self.begin : other.begin
-      end_at = self.end <= other.end ? self.end : other.end
-
-      begin_at <= end_at ? self.class.new(begin_at, end_at) : nil
+      offset value.end
     end
 
-    alias & intersect
-
     # Inserts an item after this one and before the next in the sequence. The
     # new item may not overlap with the two it sits between. A RuntimeError will
     # be raised if it does.
@@ -92,5 +87,9 @@ module Timed
 
       super
     end
+
+    protected def offset(time)
+      in_sequence? ? sequence.offset(time) : time
+    end
   end
 end

data/lib/timed/moment.rb

@@ -81,19 +81,6 @@ module Timed
 
     alias & intersect
 
-    # Compare the moments with others.
-    #
-    # Return -1 if the item is before the other, 0 if they overlap and 1 if the
-    # item is after the other.
-
-    # def <=>(other)
-    #   case
-    #   when before?(other) then -1
-    #   when after?(other) then 1
-    #   else 0
-    #   end
-    # end
-
     # Override the default implementation and provide a more useful
     # representation of the Timed Moment, including when it begins and ends.
     #

data/lib/timed/sequence.rb

@@ -2,8 +2,8 @@ module Timed
   # Sequence
   #
   # This class implements a sequence of Timed Items. Any object that implements
-  # the methods #begin and #end can be push to the sequence. Note that the items
-  # must be inserted in chronological order, or the sequence will raise an
+  # the methods #begin and #end can be added to the sequence. Note that the
+  # items must be inserted in chronological order, or the sequence will raise an
   # exception.
   #
   # Example
@@ -13,11 +13,19 @@ module Timed
   #
   # A sequence can also be treated like a Moment and be compared, in time, with
   # other compatible objects.
-  
+  #
+  # Sequences also provide a mechanism to offset the items in it, in time by
+  # providing the #offset method. Items can use it to offset their begin and end
+  # times on the fly.
+
   class Sequence
     include Moment
     include Linked::List
 
+    # Provide a more ideomatic name for the identity method #list.
+
+    alias sequence list
+
     # Returns the time at which the first item in the sequence, and therefore
     # the sequence as a whole, begins. If the sequence is empty, by convention,
     # it both begins and ends at time 0, giving it a 0 length.
@@ -76,6 +84,96 @@ module Timed
       end
     end
 
+    # Offset the entire sequence by specifying the coefficients of a polynomial
+    # of up to degree 2. This is then used to recalculate the begin and end
+    # times of each item in the set. The operation does not change the items but
+    # is instead performed on the fly every time either #begin or #end is
+    # called.
+    #
+    # Example
+    #   sequence.offset_by 10, 1.1, 0.01
+    #                      ^   ^    ^ Quadratic term
+    #                      |   + Linear term
+    #                      + Constant term
+    #   sequence.offset 42.0 # => 73.84
+    #
+    # c - list of coefficients, starting with the constant term and ending with,
+    #     at most, the quadratic.
+
+    def offset_by(*c)
+      body =
+        case c.length
+        when 0 then proc { |t| t }
+        when 1
+          if c[0] == 0 || !c[0]
+            proc { |t| t }
+          else
+            proc { |t| c[0] + t }
+          end
+        when 2 then proc { |t| c[0] + c[1] * t }
+        when 3 then proc { |t| c[0] + c[1] * t + c[2] * t**2 }
+        else
+          raise ArgumentError,
+                'Only polynomilas of order 2 or lower are supported'
+        end
+
+      redefine_method :offset, body
+    end
+
+    alias offset= offset_by
+
+    # Offset any time using the current offset settings of the sequence. Note
+    # that this method is overridden everytime #offset_by is called.
+    #
+    # time - the time to be offset.
+    #
+    # Returns the offset time.
+
+    def offset(time)
+      time
+    end
+
+    # Iterate over all of the edges in the sequence. An edge is the point in
+    # time when an item either begins or ends. That time, a numeric value, will
+    # be yielded to the block. If a block is not given and enumerator is
+    # returned.
+    #
+    # Returns an enumerator if a block was not given.
+
+    def each_edge
+      return to_enum __callee__ unless block_given?
+
+      each_item do |item|
+        yield item.begin
+        yield item.end
+      end
+    end
+
+    # Iterates over all the leading edges in the sequence. A leading edge is the
+    # point in time where an item begins. That time, a numeric value, will be
+    # yielded to the block. If a block is not given and enumerator is returned.
+    #
+    # Returns an enumerator if a block was not given.
+
+    def each_leading_edge
+      return to_enum __callee__ unless block_given?
+
+      each_item { |item| yield item.begin }
+    end
+
+    # Iterates over all the trailing edges in the sequence. A trailing edge is
+    # the point in time where an item begins. That time, a numeric value, will
+    # be yielded to the block. If a block is not given and enumerator is
+    # returned.
+    #
+    # Returns an enumerator if a block was not given.
+
+    def each_trailing_edge
+      return to_enum __callee__ unless block_given?
+
+      each_item { |item| yield item.end }
+    end
+
     # This method takes a second sequence and iterates over each intersection
     # between the two. If a block is given, the beginning and end of each
     # intersecting period will be yielded to it. Otherwise an enumerator is
@@ -84,10 +182,9 @@ module Timed
     # other - a sequence, or object that responds to #begin and #end and returns
     #         a Timed::Item in response to #first
     #
-    # Returns an enumerator unless a block is given, in which case the number of
-    # intersections is returned.
+    # Returns an enumerator unless a block is given.
 
-    def intersections(other)
+    def intersections(other, &block)
       return to_enum __callee__, other unless block_given?
 
       return unless during? other
@@ -95,16 +192,14 @@ module Timed
       # Sort the first items from each sequence into leading
       # and trailing by whichever begins first
       if self.begin <= other.begin
-        item_l, item_t = first, other.first
+        item_l, item_t = self.item, other.item
       else
-        item_l, item_t = other.first, first
+        item_l, item_t = other.item, self.item
       end
 
-      count = 0
-
       loop do
         # Now there are three posibilities:
-        
+
         # 1: The leading item ends before the trailing one
         #    begins. In this case the items do not intersect
         #    at all and we do nothing.
@@ -114,12 +209,10 @@ module Timed
         #    ends
         elsif item_l.end <= item_t.end
           yield item_t.begin, item_l.end
-          count += 1
 
         # 3: The leading item ends after the trailing one
         else
           yield item_t.begin, item_t.end
-          count += 1
 
           # Swap leading and trailing
           item_l, item_t = item_t, item_l
@@ -131,8 +224,6 @@ module Timed
         # Swap leading and trailing if needed
         item_l, item_t = item_t, item_l if item_l.begin > item_t.begin
       end
-
-      count
     end
 
     # Returns a new sequence with items that make up the intersection between
@@ -140,15 +231,75 @@ module Timed
 
     def intersect(other)
       intersections(other)
-        .with_object(self.class.new) { |(b, e), a| a << Item.new(b, e) }
+        .with_object(self.class.new) { |(b, e), a| a << create_item(b, e) }
     end
 
     alias & intersect
 
     # More efficient than first calling #intersect and then #time on the result.
+    #
+    # from - a point in time to start from.
+    # to - a point in time to stop at.
+    #
+    # Returns the total time of the intersection between this sequence and the
+    # other one.
+
+    def intersect_time(other, from: nil, to: nil)
+      enum = intersections(other)
+      total = 0
+
+      if from
+        # Reuse the variable total. It's perhaps a bit messy
+        # and confusing but it works.
+        _, total = enum.next until total > from
+        total -= from
+      end
+
+      if to
+        loop do
+          b, e = enum.next
+
+          if e > to
+            total += to - b unless b >= to
+            break
+          end
+
+          total += e - b
+        end
+      else
+        loop do
+          b, e = enum.next
+          total += e - b
+        end
+      end
+
+      total
+    rescue StopIteration
+      return 0
+    end
+
+    # Protected factory method for creating items compatible with the sequence.
+    # This method is called whenever an arbitrary object is pushed or unshifted
+    # onto the list and need to be wraped inside an Item.
+    #
+    # args - any arguments will be passed on to Item.new.
+    #
+    # Returns a new Item.
+
+    protected def create_item(*args)
+      Item.new(*args)
+    end
+
+    # Private helper method for (re)defining method on the singleton class.
+    #
+    # name - symbol name of the method.
+    # body - proc that will be used as method body.
 
-    def intersect_time(other)
-      intersections(other).reduce(0) { |a, (b, e)| a + e - b }
+    private def redefine_method name, body
+      singleton_class.send :remove_method, name
+    rescue NameError
+    ensure
+      singleton_class.send :define_method, name, body
     end
   end
 end

data/lib/timed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Timed
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/timed.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "linked", "~> 0.1.3"
+  spec.add_dependency "linked", "~> 0.3"
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timed
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Sebastian Lindberg
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-08 00:00:00.000000000 Z
+date: 2016-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: linked
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.3
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.3
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement