Class: Timely::TemporalPatterns::Frequency

Inherits:
Object
  • Object
show all
Defined in:
lib/timely/temporal_patterns/frequency.rb

Constant Summary collapse

UNITS = 
[:second, :minute, :hour, :day, :week, :fortnight, :month, :year]

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(duration) ⇒ Frequency

Returns a new instance of Frequency.



8
9
10
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 8

def initialize(duration)
  self.duration = duration
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Object (private)

:nodoc:



103
104
105
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 103

def method_missing(method, *args, &block) #:nodoc:
  duration.send(method, *args, &block)
end

Instance Attribute Details

#duration ⇒ Object

Returns the value of attribute duration.



6
7
8
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 6

def duration
  @duration
end

Class Method Details

.decompose(duration) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 78

def decompose(duration)
  whole = duration
  parts = []
  plural_units.reverse_each do |unit|
    if whole >= (one_unit = 1.send(unit))
      current_unit_value = ((whole / one_unit).floor)
      if current_unit_value > 0
        parts << [unit, current_unit_value]
        whole -= current_unit_value.send(unit)
      end
    end
  end
  parts
end

.decompose_to_hash(duration) ⇒ Object 



93
94
95
96
97
98
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 93

def decompose_to_hash(duration)
  decompose(duration).inject({}) do |hash, unit|
    hash[unit.first] = unit.last
    hash
  end
end

.parse(duration) ⇒ Object 



70
71
72
73
74
75
76
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 70

def parse(duration)
  parsed = 0.seconds
  decompose(duration).each do |part|
    parsed += part.last.send(part.first)
  end
  parsed
end

.plural_units ⇒ Object 



54
55
56
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 54

def plural_units
  UNITS.map { |unit| unit.to_s.pluralize.to_sym }
end

.singular_units ⇒ Object 



50
51
52
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 50

def singular_units
  UNITS.dup
end

.unit_durations ⇒ Object 



58
59
60
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 58

def unit_durations
  UNITS.map { |unit| 1.call(unit) }
end

.valid_unit?(unit) ⇒ Boolean

Returns:

  • (Boolean) 


66
67
68
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 66

def valid_unit?(unit)
  valid_units.include?(unit.to_s.to_sym)
end

.valid_units ⇒ Object 



62
63
64
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 62

def valid_units
  singular_units + plural_units
end

Instance Method Details

#<=>(other) ⇒ Object 



18
19
20
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 18

def <=>(other)
  self.duration <=> other.duration
end

#max_unit ⇒ Object 



40
41
42
43
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 40

def max_unit
  parts = self.class.decompose(duration)
  {parts.first.first => parts.first.last}
end

#min_unit ⇒ Object 



35
36
37
38
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 35

def min_unit
  parts = self.class.decompose(duration)
  {parts.last.first => parts.last.last}
end

#to_s ⇒ Object 



22
23
24
25
26
27
28
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 22

def to_s
   "every " + duration.parts.
                reduce(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }.
                sort_by {|unit,  _ | [:years, :months, :days, :minutes, :seconds].index(unit)}.
                map     {|unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}" if val.nonzero?}.compact.
                to_sentence(:locale => :en)
end

#unit ⇒ Object 



30
31
32
33
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 30

def unit
  parts = self.class.decompose(duration)
  parts.size == 1 && parts.first.last == 1? parts.first.first : nil
end

#units ⇒ Object 



45
46
47
 
# File 'lib/timely/temporal_patterns/frequency.rb', line 45

def units
  self.class.decompose_to_hash(duration)
end