Class: Timerage::TimeInterval

Inherits:
Range
  • Object
show all
Defined in:
lib/timerage/time_interval.rb

Overview

A range of time. The exposes the Range like interface.

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ TimeInterval

Returns a new instance of TimeInterval.



6
7
8
9
10
11
12
13
14
 
# File 'lib/timerage/time_interval.rb', line 6

def initialize(*args)
  rng = if rangeish?(args.first)
          args.first
        else
          Range.new(*args)
        end

  super rng
end

Instance Method Details

#+(other) ⇒ Object

Return new TimeInterval that is the concatenation of self and other (if possible).

Raises ArgumentError if other is not adjacent to self chronologically.



48
49
50
51
52
 
# File 'lib/timerage/time_interval.rb', line 48

def +(other)
  fail ArgumentError, "other must be adjacent to self" unless adjacent_to?(other)

  self.class.new([self.begin, other.begin].min, [self.end, other.end].max)
end

#<=>(other) ⇒ Object 



93
94
95
96
97
 
# File 'lib/timerage/time_interval.rb', line 93

def <=>(other)
  return super unless rangeish?(other)

  self.begin <=> other.begin
end

#==(other) ⇒ Object 



34
35
36
37
38
39
40
41
 
# File 'lib/timerage/time_interval.rb', line 34

def ==(other)
  self.begin == other.begin &&
    self.end == other.end &&
    self.exclude_end? == other.exclude_end?

rescue NoMethodError
  false
end

#adjacent_to?(other) ⇒ Boolean

Returns:

  • (Boolean) 


60
61
62
 
# File 'lib/timerage/time_interval.rb', line 60

def adjacent_to?(other)
  other.begin == self.end || other.end == self.begin
end

#cover?(time_or_interval) ⇒ Boolean

Returns:

  • (Boolean) 


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/timerage/time_interval.rb', line 64

def cover?(time_or_interval)
  return super unless rangeish?(time_or_interval)

  other = time_or_interval

  self.begin <= other.begin &&
    if self.exclude_end? && other.exclude_end?
      self.end > other.begin && self.begin < other.end && other.end <= self.end

    elsif self.exclude_end?
      self.end > other.begin && self.begin <= other.end && other.end < self.end

    elsif other.exclude_end?
      self.end >= other.begin && self.begin < other.end && other.end <= self.end

    else
      self.end >= other.begin && self.begin <= other.end && other.end <= self.end
    end
end

#iso8601(*args) ⇒ Object

Returns an ISO8601 interval representation of self Takes same args as Time#iso8601



56
57
58
 
# File 'lib/timerage/time_interval.rb', line 56

def iso8601(*args)
  "#{self.begin.iso8601(*args)}/#{self.end.iso8601(*args)}"
end

#overlap?(other) ⇒ Boolean

Returns:

  • (Boolean) 


84
85
86
87
88
89
90
91
 
# File 'lib/timerage/time_interval.rb', line 84

def overlap?(other)
  cover?(other) ||
    other.cover?(self) ||
    cover?(other.begin) ||
    other.cover?(self.begin) ||
    cover?(other.end) && (!other.exclude_end? || other.end != self.begin) ||
    other.cover?(self.end) && (!self.exclude_end? || other.begin != self.end)
end

#slice(seconds) ⇒ Object 



26
27
28
29
30
31
32
 
# File 'lib/timerage/time_interval.rb', line 26

def slice(seconds)
  time_enumerator(seconds)
    .map{|t|
      end_time = [t+seconds, self.end].min
      inclusive = (self.end == t && !exclude_end?) || t+seconds > self.end
      TimeInterval.new(t, end_time, !inclusive) }
end

#step(n, &blk) ⇒ Object 



18
19
20
21
22
23
24
 
# File 'lib/timerage/time_interval.rb', line 18

def step(n, &blk)
  if block_given?
    time_enumerator(n).each(&blk)
  else
    time_enumerator(n)
  end
end