class Chronic::Handler

def ==(other)

Returns:
  • (Boolean) - True if these handlers match

Parameters:
  • The (Handler) -- handler to compare 
def ==(other)
  @pattern == other.pattern
end

def constantize(name)

Raises:
  • (NameError) - Raises if this constant could not be found

Returns:
  • (Class) - The class represented by `name`

Parameters:
  • The (#to_s) -- snake_case name representing a Chronic constant 
def constantize(name)
  Chronic.const_get name.to_s.gsub(/(^|_)(.)/) { $2.upcase }
end

def initialize(pattern, handler_method)

Parameters:
  • handler_method (Symbol) -- The method to be invoked when patterns
  • pattern (Array) -- A list of patterns to match tokens against 
def initialize(pattern, handler_method)
  @pattern = pattern
  @handler_method = handler_method
end

def match(tokens, definitions)

Other tags:
    See: Chronic.tokens_to_span -

Returns:
  • (Boolean) -

Parameters:
  • definitions (Hash) --
  • tokens (Array) -- 
def match(tokens, definitions)
  token_index = 0
  @pattern.each do |element|
    name = element.to_s
    optional = name[-1, 1] == '?'
    name = name.chop if optional
    if element.instance_of? Symbol
      klass = constantize(name)
      match = tokens[token_index] && !tokens[token_index].tags.select { |o| o.kind_of?(klass) }.empty?
      return false if !match && !optional
      (token_index += 1; next) if match
      next if !match && optional
    elsif element.instance_of? String
      return true if optional && token_index == tokens.size
      sub_handlers = definitions[name.intern] || raise(ChronicPain, "Invalid subset #{name} specified")
      sub_handlers.each do |sub_handler|
        return true if sub_handler.match(tokens[token_index..tokens.size], definitions)
      end
      return false
    else
      raise(ChronicPain, "Invalid match type: #{element.class}")
    end
  end
  return false if token_index != tokens.size
  return true
end