Module: Remi::Testing::BusinessRules::ParseFormula

Extended by:
ParseFormula
Included in:
ParseFormula
Defined in:
lib/remi/testing/business_rules.rb

Instance Method Summary collapse

Instance Method Details

#base_regex ⇒ Object 



26
27
28
 
# File 'lib/remi/testing/business_rules.rb', line 26

def base_regex
  @base_regex ||= /\*(.*)\*/
end

#date_reference(formula, captured) ⇒ Object 



63
64
65
66
67
 
# File 'lib/remi/testing/business_rules.rb', line 63

def date_reference(formula, captured)
  parsed = self.send("date_reference_#{formula}", *captured)
  Date.current.send("#{parsed[:unit]}_#{parsed[:direction]}", parsed[:quantity]).strftime(parsed[:format])

end

#date_reference_match_multiple(form, quantity, unit, direction, format = nil) ⇒ Object 



119
120
121
122
123
124
125
126
 
# File 'lib/remi/testing/business_rules.rb', line 119

def date_reference_match_multiple(form, quantity, unit, direction, format=nil)
  {
    quantity: quantity.to_i,
    unit: unit.downcase.pluralize,
    direction: { 'ago' => 'ago', 'from now' => 'since' }[direction.downcase],
    format: parse_colon_date_format(format)
  }
end

#date_reference_match_single_day(form, direction, format = nil) ⇒ Object 



101
102
103
104
105
106
107
108
 
# File 'lib/remi/testing/business_rules.rb', line 101

def date_reference_match_single_day(form, direction, format=nil)
  {
    quantity: direction.downcase == 'today' ? 0 : 1,
    unit: 'days',
    direction: { 'today' => 'ago', 'yesterday' => 'ago', 'tomorrow' => 'since' }[direction.downcase],
    format: parse_colon_date_format(format)
  }
end

#date_reference_match_single_unit(form, direction, unit, format = nil) ⇒ Object 



110
111
112
113
114
115
116
117
 
# File 'lib/remi/testing/business_rules.rb', line 110

def date_reference_match_single_unit(form, direction, unit, format=nil)
  {
    quantity: direction.downcase == 'this' ? 0 : 1,
    unit: unit.downcase.pluralize,
    direction: { 'this' => 'ago', 'last' => 'ago', 'previous' => 'ago', 'next' => 'since' }[direction.downcase],
    format: parse_colon_date_format(format)
  }
end

#formulas ⇒ Object 



30
31
32
33
34
35
36
37
38
 
# File 'lib/remi/testing/business_rules.rb', line 30

def formulas
  @formulas ||= RegexSieve.new({
    /\*now(|:[^*]+)\*/i => [:time_reference, :match_now],
    /\*(\d+)\s(hour|hours|minute|minutes) (ago|from now)(|:[^*]+)\*/i => [:time_reference, :match_time],
    /\*(today|yesterday|tomorrow)(|:[^*]+)\*/i => [:date_reference, :match_single_day],
    /\*(this|last|previous|next) (day|month|year|week)(|:[^*]+)\*/i => [:date_reference, :match_single_unit],
    /\*(\d+)\s(day|days|month|months|year|years|week|weeks) (ago|from now)(|:[^*]+)\*/i => [:date_reference, :match_multiple]
  })
end

#is_formula?(arg) ⇒ Boolean

Returns:

  • (Boolean) 


22
23
24
 
# File 'lib/remi/testing/business_rules.rb', line 22

def is_formula?(arg)
  !base_regex.match(arg).nil?
end

#parse(form) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/remi/testing/business_rules.rb', line 40

def parse(form)
  return form unless is_formula?(form)

  form_opt = formulas[form, :match]
  raise "Unknown formula #{form}" unless form_opt[:match]

  to_replace = form.match(base_regex)[0]
  replace_with = if form_opt[:value][0] == :date_reference
                   date_reference(form_opt[:value][1], form_opt[:match])
                 elsif form_opt[:value][0] == :time_reference
                   time_reference(form_opt[:value][1], form_opt[:match])
                 else
                   to_replace
                 end

  form.gsub(to_replace, replace_with)
end

#parse_colon_date_format(str) ⇒ Object 



69
70
71
 
# File 'lib/remi/testing/business_rules.rb', line 69

def parse_colon_date_format(str)
  str.blank? ? '%Y-%m-%d' : str.slice(1..-1).strip
end

#parse_colon_time_format(str) ⇒ Object 



73
74
75
 
# File 'lib/remi/testing/business_rules.rb', line 73

def parse_colon_time_format(str)
  str.blank? ? '%Y-%m-%d %H:%M:%S' : str.slice(1..-1).strip
end

#time_reference(formula, captured) ⇒ Object 



58
59
60
61
 
# File 'lib/remi/testing/business_rules.rb', line 58

def time_reference(formula, captured)
  parsed = self.send("time_reference_#{formula}", *captured)
  Time.current.send("#{parsed[:unit]}_#{parsed[:direction]}", parsed[:quantity]).strftime(parsed[:format])
end

#time_reference_match_now(form, format = nil) ⇒ Object 



77
78
79
80
81
82
83
84
 
# File 'lib/remi/testing/business_rules.rb', line 77

def time_reference_match_now(form, format=nil)
  {
    quantity: 0,
    unit: 'days',
    direction: 'ago',
    format: parse_colon_time_format(format)
  }
end

#time_reference_match_time(form, quantity, unit, direction, format = nil) ⇒ Object 



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/remi/testing/business_rules.rb', line 85

def time_reference_match_time(form, quantity, unit, direction, format=nil)
  divisor = 1.0
  if unit.downcase.pluralize =='hours'
    divisor = 24.0
  elsif unit.downcase.pluralize == 'minutes'
    divisor = 24.0*60.0
  end

  {
    quantity: quantity.to_i/divisor,
    unit: 'days',
    direction: { 'ago' => 'ago', 'from now' => 'since' }[direction.downcase],
    format: parse_colon_time_format(format)
  }
end