Class: Chronic::Parser

Inherits:
Object
  • Object
show all
Includes:
Handlers
Defined in:
lib/chronic/parser.rb

Constant Summary collapse

DEFAULT_OPTIONS =

Hash of default configuration options.

{
  :context => :future,
  :now => nil,
  :hours24 => nil,
  :guess => true,
  :ambiguous_time_range => 6,
  :endian_precedence    => [:middle, :little],
  :ambiguous_year_future_bias => 50
}

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Handlers

day_or_time, dealias_and_disambiguate_times, find_within, get_anchor, get_repeaters, handle_generic, handle_m_d, handle_o_r_g_r, handle_o_r_s_r, handle_od_rm, handle_od_rmn, handle_od_rmn_sy, handle_orr, handle_p_s_r, handle_r, handle_r_g_r, handle_rdn_od, handle_rdn_rmn_od, handle_rdn_rmn_od_sy, handle_rdn_rmn_sd, handle_rdn_rmn_sd_sy, handle_rmn_od, handle_rmn_od_on, handle_rmn_od_sy, handle_rmn_sd, handle_rmn_sd_on, handle_rmn_sd_sy, handle_rmn_sy, handle_s_r_a_s_r_p_a, handle_s_r_p, handle_s_r_p_a, handle_sd_rmn, handle_sd_rmn_sy, handle_sd_sm, handle_sd_sm_sy, handle_sm_rmn_sy, handle_sm_sd, handle_sm_sd_sy, handle_sm_sy, handle_srp, handle_sy_rmn_od, handle_sy_sm, handle_sy_sm_sd, handle_year_and_month, month_overflow?, time_with_rollover

Constructor Details

#initialize(options = {}) ⇒ Parser

options - An optional Hash of configuration options:

:context - If your string represents a birthday, you can set
           this value to :past and if an ambiguous string is
           given, it will assume it is in the past.
:now - Time, all computations will be based off of time
       instead of Time.now.
:hours24 - Time will be parsed as it would be 24 hour clock.
:guess - By default the parser will guess a single point in time
         for the given date or time. If you'd rather have the
         entire time span returned, set this to false
         and a Chronic::Span will be returned. Setting :guess to :end
         will return last time from Span, to :middle for middle (same as just true)
         and :begin for first time from span.
:ambiguous_time_range - If an Integer is given, ambiguous times
          (like 5:00) will be assumed to be within the range of
          that time in the AM to that time in the PM. For
          example, if you set it to `7`, then the parser will
          look for the time between 7am and 7pm. In the case of
          5:00, it would assume that means 5:00pm. If `:none`
          is given, no assumption will be made, and the first
          matching instance of that time will be used.
:endian_precedence - By default, Chronic will parse "03/04/2011"
         as the fourth day of the third month. Alternatively you
         can tell Chronic to parse this as the third day of the
         fourth month by setting this to [:little, :middle].
:ambiguous_year_future_bias - When parsing two digit years
         (ie 79) unlike Rubys Time class, Chronic will attempt
         to assume the full year using this figure. Chronic will
         look x amount of years into the future and past. If the
         two digit year is `now + x years` it's assumed to be the
         future, `now - x years` is assumed to be the past.



52
53
54
55
 
# File 'lib/chronic/parser.rb', line 52

def initialize(options = {})
  @options = DEFAULT_OPTIONS.merge(options)
  @now = options.delete(:now) || Chronic.time_class.now
end

Instance Attribute Details

#now ⇒ Object

Returns the value of attribute now.



18
19
20
 
# File 'lib/chronic/parser.rb', line 18

def now
  @now
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



19
20
21
 
# File 'lib/chronic/parser.rb', line 19

def options
  @options
end

Instance Method Details

#definitions(options = {}) ⇒ Object

List of Handler definitions. See Chronic.parse for a list of options this method accepts.

options - An optional Hash of configuration options.

Returns a Hash of Handler definitions.



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/chronic/parser.rb', line 146

def definitions(options = {})
  options[:endian_precedence] ||= [:middle, :little]

  @@definitions ||= {
    :time => [
      Handler.new([:repeater_time, :repeater_day_portion?], nil)
    ],

    :date => [
      Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :repeater_time, [:separator_slash?, :separator_dash?], :time_zone, :scalar_year], :handle_generic),
      Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day], :handle_rdn_rmn_sd),
      Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :scalar_year], :handle_rdn_rmn_sd_sy),
      Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day], :handle_rdn_rmn_od),
      Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :scalar_year], :handle_rdn_rmn_od_sy),
      Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :separator_at?, 'time?'], :handle_rdn_rmn_sd),
      Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_rmn_od),
      Handler.new([:repeater_day_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_od),
      Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_day, :repeater_time, :time_zone], :handle_generic),
      Handler.new([:ordinal_day], :handle_generic),
      Handler.new([:repeater_month_name, :scalar_day, :scalar_year], :handle_rmn_sd_sy),
      Handler.new([:repeater_month_name, :ordinal_day, :scalar_year], :handle_rmn_od_sy),
      Handler.new([:repeater_month_name, :scalar_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_sd_sy),
      Handler.new([:repeater_month_name, :ordinal_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_od_sy),
      Handler.new([:repeater_month_name, [:separator_slash?, :separator_dash?], :scalar_day, :separator_at?, 'time?'], :handle_rmn_sd),
      Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :scalar_day], :handle_rmn_sd_on),
      Handler.new([:repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rmn_od),
      Handler.new([:ordinal_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_od_rmn_sy),
      Handler.new([:ordinal_day, :repeater_month_name, :separator_at?, 'time?'], :handle_od_rmn),
      Handler.new([:ordinal_day, :grabber?, :repeater_month, :separator_at?, 'time?'], :handle_od_rm),
      Handler.new([:scalar_year, :repeater_month_name, :ordinal_day], :handle_sy_rmn_od),
      Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :ordinal_day], :handle_rmn_od_on),
      Handler.new([:repeater_month_name, :scalar_year], :handle_rmn_sy),
      Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy),
      Handler.new([:scalar_day, [:separator_slash?, :separator_dash?], :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
      Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sy_sm_sd),
      Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month], :handle_sy_sm),
      Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_year], :handle_sm_sy),
      Handler.new([:scalar_day, [:separator_slash, :separator_dash], :repeater_month_name, [:separator_slash, :separator_dash], :scalar_year, :repeater_time?], :handle_sm_rmn_sy),
      Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar?, :time_zone], :handle_generic),
    ],

    :anchor => [
      Handler.new([:separator_on?, :grabber?, :repeater, :separator_at?, :repeater?, :repeater?], :handle_r),
      Handler.new([:grabber?, :repeater, :repeater, :separator?, :repeater?, :repeater?], :handle_r),
      Handler.new([:repeater, :grabber, :repeater], :handle_r_g_r)
    ],

    :arrow => [
      Handler.new([:scalar, :repeater, :pointer], :handle_s_r_p),
      Handler.new([:scalar, :repeater, :separator_and?, :scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_a_s_r_p_a),
      Handler.new([:pointer, :scalar, :repeater], :handle_p_s_r),
      Handler.new([:scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_p_a)
    ],

    :narrow => [
      Handler.new([:ordinal, :repeater, :separator_in, :repeater], :handle_o_r_s_r),
      Handler.new([:ordinal, :repeater, :grabber, :repeater], :handle_o_r_g_r)
    ]
  }

  endians = [
    Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
    Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
    Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
    Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
  ]

  case endian = Array(options[:endian_precedence]).first
  when :little
    @@definitions.merge(:endian => endians.reverse)
  when :middle
    @@definitions.merge(:endian => endians)
  else
    raise ArgumentError, "Unknown endian option '#{endian}'"
  end
end

#guess(span, mode = :middle) ⇒ Object

Guess a specific time within the given span.

span - The Chronic::Span object to calcuate a guess from.

Returns a new Time object.



133
134
135
136
137
138
 
# File 'lib/chronic/parser.rb', line 133

def guess(span, mode = :middle)
  return span if not mode
  return span.begin + span.width / 2 if span.width > 1 and (mode == true or mode == :middle)
  return span.end if mode == :end
  span.begin
end

#parse(text) ⇒ Object

Parse “text” with the given options Returns either a Time or Chronic::Span, depending on the value of options



59
60
61
62
63
64
65
66
 
# File 'lib/chronic/parser.rb', line 59

def parse(text)
  tokens = tokenize(text, options)
  span = tokens_to_span(tokens, options.merge(:text => text))

  puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}" if Chronic.debug

  guess(span, options[:guess]) if span
end

#pre_normalize(text) ⇒ Object

Clean up the specified text ready for parsing.

Clean up the string by stripping unwanted characters, converting idioms to their canonical form, converting number words to numbers (three => 3), and converting ordinal words to numeric ordinals (third => 3rd)

text - The String text to normalize.

Examples:

Chronic.pre_normalize('first day in May')
  #=> "1st day in may"

Chronic.pre_normalize('tomorrow after noon')
  #=> "next day future 12:00"

Chronic.pre_normalize('one hundred and thirty six days from now')
  #=> "136 days future this second"

Returns a new String ready for Chronic to parse.



89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/chronic/parser.rb', line 89

def pre_normalize(text)
  text = text.to_s.downcase
  text.gsub!(/\b(\d{2})\.(\d{2})\.(\d{4})\b/, '\3 / \2 / \1')
  text.gsub!(/\b([ap])\.m\.?/, '\1m')
  text.gsub!(/(\s+|:\d{2}|:\d{2}\.\d{3})\-(\d{2}:?\d{2})\b/, '\1tzminus\2')
  text.gsub!(/\./, ':')
  text.gsub!(/([ap]):m:?/, '\1m')
  text.gsub!(/['"]/, '')
  text.gsub!(/,/, ' ')
  text.gsub!(/^second /, '2nd ')
  text.gsub!(/\bsecond (of|day|month|hour|minute|second)\b/, '2nd \1')
  text = Numerizer.numerize(text)
  text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
  text.gsub!(/(?:^|\s)0(\d+:\d+\s*pm?\b)/, ' \1')
  text.gsub!(/\btoday\b/, 'this day')
  text.gsub!(/\btomm?orr?ow\b/, 'next day')
  text.gsub!(/\byesterday\b/, 'last day')
  text.gsub!(/\bnoon\b/, '12:00pm')
  text.gsub!(/\bmidnight\b/, '24:00')
  text.gsub!(/\bnow\b/, 'this second')
  text.gsub!('quarter', '15')
  text.gsub!('half', '30')
  text.gsub!(/(\d{1,2}) (to|till|prior to|before)\b/, '\1 minutes past')
  text.gsub!(/(\d{1,2}) (after|past)\b/, '\1 minutes future')
  text.gsub!(/\b(?:ago|before(?: now)?)\b/, 'past')
  text.gsub!(/\bthis (?:last|past)\b/, 'last')
  text.gsub!(/\b(?:in|during) the (morning)\b/, '\1')
  text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/, '\1')
  text.gsub!(/\btonight\b/, 'this night')
  text.gsub!(/\b\d+:?\d*[ap]\b/,'\0m')
  text.gsub!(/\b(\d{2})(\d{2})(am|pm)\b/, '\1:\2\3')
  text.gsub!(/(\d)([ap]m|oclock)\b/, '\1 \2')
  text.gsub!(/\b(hence|after|from)\b/, 'future')
  text.gsub!(/^\s?an? /i, '1 ')
  text.gsub!(/\b(\d{4}):(\d{2}):(\d{2})\b/, '\1 / \2 / \3') # DTOriginal
  text.gsub!(/\b0(\d+):(\d{2}):(\d{2}) ([ap]m)\b/, '\1:\2:\3 \4')
  text
end