lib/chronic/handlers.rb in chronic-0.4.3 vs lib/chronic/handlers.rb in chronic-0.4.4

@@ -100,11 +100,11 @@
 
     # Handle scalar-day/repeater-month-name/scalar-year
     def handle_sd_rmn_sy(tokens, options) #:nodoc:
       new_tokens = [tokens[1], tokens[0], tokens[2]]
       time_tokens = tokens.last(tokens.size - 3)
-      self.handle_rmn_sd_sy(new_tokens + time_tokens, options)
+      handle_rmn_sd_sy(new_tokens + time_tokens, options)
     end
 
     # Handle scalar-month/scalar-day/scalar-year (endian middle)
     def handle_sm_sd_sy(tokens, options) #:nodoc:
       month = tokens[0].get_tag(ScalarMonth).type
@@ -123,18 +123,18 @@
 
     # Handle scalar-day/scalar-month/scalar-year (endian little)
     def handle_sd_sm_sy(tokens, options) #:nodoc:
       new_tokens = [tokens[1], tokens[0], tokens[2]]
       time_tokens = tokens.last(tokens.size - 3)
-      self.handle_sm_sd_sy(new_tokens + time_tokens, options)
+      handle_sm_sd_sy(new_tokens + time_tokens, options)
     end
 
     # Handle scalar-year/scalar-month/scalar-day
     def handle_sy_sm_sd(tokens, options) #:nodoc:
       new_tokens = [tokens[1], tokens[2], tokens[0]]
       time_tokens = tokens.last(tokens.size - 3)
-      self.handle_sm_sd_sy(new_tokens + time_tokens, options)
+      handle_sm_sd_sy(new_tokens + time_tokens, options)
     end
 
     # Handle scalar-month/scalar-year
     def handle_sm_sy(tokens, options) #:nodoc:
       month = tokens[0].get_tag(ScalarMonth).type
@@ -158,17 +158,17 @@
     # anchors
 
     # Handle repeaters
     def handle_r(tokens, options) #:nodoc:
       dd_tokens = dealias_and_disambiguate_times(tokens, options)
-      self.get_anchor(dd_tokens, options)
+      get_anchor(dd_tokens, options)
     end
 
     # Handle repeater/grabber/repeater
     def handle_r_g_r(tokens, options) #:nodoc:
       new_tokens = [tokens[1], tokens[0], tokens[2]]
-      self.handle_r(new_tokens, options)
+      handle_r(new_tokens, options)
     end
 
     # arrows
 
     # Handle scalar/repeater/pointer helper
@@ -183,23 +183,23 @@
     # Handle scalar/repeater/pointer
     def handle_s_r_p(tokens, options) #:nodoc:
       repeater = tokens[1].get_tag(Repeater)
       span = Span.new(Chronic.now, Chronic.now + 1)
 
-      self.handle_srp(tokens, span, options)
+      handle_srp(tokens, span, options)
     end
 
     # Handle pointer/scalar/repeater
     def handle_p_s_r(tokens, options) #:nodoc:
       new_tokens = [tokens[1], tokens[2], tokens[0]]
-      self.handle_s_r_p(new_tokens, options)
+      handle_s_r_p(new_tokens, options)
     end
 
     # Handle scalar/repeater/pointer/anchor
     def handle_s_r_p_a(tokens, options) #:nodoc:
       anchor_span = get_anchor(tokens[3..tokens.size - 1], options)
-      self.handle_srp(tokens, anchor_span, options)
+      handle_srp(tokens, anchor_span, options)
     end
 
     # narrows
 
     # Handle oridinal repeaters
@@ -245,11 +245,11 @@
 
     def get_anchor(tokens, options) #:nodoc:
       grabber = Grabber.new(:this)
       pointer = :future
 
-      repeaters = self.get_repeaters(tokens)
+      repeaters = get_repeaters(tokens)
       repeaters.size.times { tokens.pop }
 
       if tokens.first && tokens.first.get_tag(Grabber)
         grabber = tokens.first.get_tag(Grabber)
         tokens.pop
@@ -356,22 +356,37 @@
       tokens
     end
 
   end
 
-  class Handler #:nodoc:
-    attr_accessor :pattern, :handler_method
+  class Handler
+    # @return [Array] A list of patterns
+    attr_accessor :pattern
 
+    # @return [Symbol] The method which handles this list of patterns.
+    #   This method should exist inside the {Handlers} module
+    attr_accessor :handler_method
+
+    # @param [Array]  pattern A list of patterns to match tokens against
+    # @param [Symbol] handler_method The method to be invoked when patterns
+    #   are matched. This method should exist inside the {Handlers} module
     def initialize(pattern, handler_method)
       @pattern = pattern
       @handler_method = handler_method
     end
 
+    # @param [#to_s]  The snake_case name representing a Chronic constant
+    # @return [Class] The class represented by `name`
+    # @raise [NameError] Raises if this constant could not be found
     def constantize(name)
       Chronic.const_get name.to_s.gsub(/(^|_)(.)/) { $2.upcase }
     end
 
+    # @param [Array] tokens
+    # @param [Hash]  definitions
+    # @return [Boolean]
+    # @see Chronic.tokens_to_span
     def match(tokens, definitions)
       token_index = 0
       @pattern.each do |element|
         name = element.to_s
         optional = name[-1, 1] == '?'
@@ -395,11 +410,13 @@
       end
       return false if token_index != tokens.size
       return true
     end
 
+    # @param [Handler]  The handler to compare
+    # @return [Boolean] True if these handlers match
     def ==(other)
-      self.pattern == other.pattern
+      @pattern == other.pattern
     end
   end
 
 end