RubyGems - date_parser - Versions diffs - 0.1.32 → 0.1.41 - Mend

date_parser 0.1.32 → 0.1.41

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

checksums.yaml +4 -4
data/NEWS.md +6 -0
data/README.md +2 -0
data/lib/date_parser/natural_date_parsing.rb +413 -405
data/lib/date_parser/utils.rb +46 -42
data/lib/spec/natural_date_parsing_spec.rb +22 -22
metadata +2 -3
data/lib/date_parser/date_utils.rb +0 -0

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ddb095af53cceacb9a7b225fe35e7e0394eab5a
-  data.tar.gz: 3dad721f0e8209cd16bb2428b5c7f69548b6c843
+  metadata.gz: 592cec3a9d927234909d05075ffc420aad8215e9
+  data.tar.gz: ca673826410f557feedea6ac8d44ed5518cf76c0
 SHA512:
-  metadata.gz: 04001838b9215d7ddf43d24d53f2b07eb39cc472a5a54d9959144056dd93cd063e4d7adcde1e0720bdbd5aa09159852fb4af804295fb7725e867fad8a20b8b60
-  data.tar.gz: 08996a4436fa3371c948b280d061107fd8d705dd4f43d1e90fa9e65c462d8ee158c53f088d52e3574e07e19ae0c5146a6c0bc653b63568f5ac9e59451e837431
+  metadata.gz: 01f07e1867c72a4c81afa994f4c43391182410b4a61c24f4d2c1a4884d18764d10495d1dccd48af3abd84092ca779cbe355d4abe70d48c14023c0fc011dad048
+  data.tar.gz: 1174abd562af7bc04eb9f1b4041fa9b1096841ff07cf7b0de63a65943c59cde210f8bb18b4236c42b3137627137fba6a45da9757f1d420d0cc879125d0853bb3

data/NEWS.md CHANGED Viewed

@@ -1,3 +1,9 @@
+# DateParser 0.1.4
+* Improved namespacing.
+    + NaturalDateParsing and Utils now part of the DateParser namespace.
+* Removed an unused utils file.
+* Some documentation expansion.
 # DateParser 0.1.3
 * New internal checks to avoid ambiguous behavior.
     + Notably: creation_date is enforced to be a descendent of the Date class.

data/README.md CHANGED Viewed

@@ -1,3 +1,5 @@
+[![Gem Version](https://badge.fury.io/rb/date_parser.svg)](https://badge.fury.io/rb/date_parser)
 # DateParser
 DateParser is a simple, fast, effective way of parsing dates from natural language

data/lib/date_parser/natural_date_parsing.rb CHANGED Viewed

@@ -1,476 +1,484 @@
-require_relative 'date_utils'
 require_relative "utils"
-# Handles the mechanics of natural language processing.
-#
-# == Methods
-#
-# <b>interpret_date(txt, creation_date, parse_single_years)</b>:
-# Return an array of dates from the set of parameters.
-#
-# We parse in order of decreasing
-# strictness. I.e., a very specific phrase like "January 1st, 2013" will be parsed
-# before "January 1st," which will be parsed before just "2013". Whenever we
-# determine a phrase is part of a date, we remove the phrase after parsing.
-# So in the example "January 1st, 2013" we'll return only one date.
-#
-# If no dates are found, returns an empty array.
-#
-# <b>parse_one_word(word, creation_date, parse_single_years)</b>: Given a single word,
-# a string, tries to return a Date object.
-#
-module NaturalDateParsing
-  ###############################################
-  ##
-  ## Constants
-  ##
-  # Names of days as well as common shortened versions.
-  SINGLE_DAYS = [
-                 'mon', 'tue', 'wed', 'thur', 'fri', 'sat', 'sun',
-                 'monday', 'tuesday', 'wednesday', 'thursday', 'friday',
-                 'saturday', 'sunday', 'tues'
-                ]
-  # Phrases that denote a date relative to today (here often
-  # called the creation_date)
-  RELATIVE_DAYS = ['today', 'tomorrow', 'tonight', 'yesterday']
-  # Names of months as well as common shortened versions
-  MONTH = [
-           'jan', 'feb', 'mar', 'may', 'june', 'july', 'aug', 'sept', 'oct',
-           'nov', 'dec',
-           'january', 'february', 'march', 'april', 'august', 'september',
-           'october', 'november', 'december'
-          ]
-  # A list of numbers from [1, 31]
-  NUMERIC_DAY = ('1'..'31').to_a
-  # Numbers from [1, 31] as well as the common suffixes (such as 1st, 2nd, e.t.c.)
-  SUFFIXED_NUMERIC_DAY = [
-                           '1st', '2nd', '3rd', '4th', '5th', '6th', '7th',
-                           '8th', '9th', '10th', '11th', '12th', '13th', '14th',
-                           '15th', '16th', '17th', '18th', '19th', '20th',
-                           '21st', '22nd', '23rd','24th', '25th',
-                           '26th', '27th', '28th', '29th', '30th', '31st'
-                         ]
+module DateParser
-  ###############################################
-  ##
-  ## Main Parsing/Processing Function
-  ##
-  # Processes a given text and returns an array of probable dates contained within.
-  #
-  # ==== Description
-  #
-  # Tries to interpret dates from the given text, in order from strictest
-  # interpretation to looser interpretations. No word can be part of two
-  # different dates.
-  #
-  # Works by calling parse_three_words, parse_two_words, and parse_one_word
-  # on the text.
-  #
-  # ==== Attributes
-  #
-  # * +txt+ - The text to parse.
+  # Handles the mechanics of natural language processing.
   #
-  # * +creation_date+ - A Date object of when the text was created or released.
-  #   Defaults to nil, but if provided can make returned dates more accurate.
+  # == Methods
   #
-  # * +parse_single_years+ - A boolean. If true, we interpret single numbers as
-  #   years. This is a very broad assumption, and so defaults to false.
+  # <b>interpret_date(txt, creation_date, parse_single_years)</b>:
+  # Return an array of dates from the set of parameters.
   #
-  # * +parse_ambiguous_dates+ - Some phrases are not necessarily dates depending
-  #   on context. For example "1st" may not refer to
-  #   the 1st of a month. This option toggles whether or not those
-  #   phrases are considered dates. Defaults to true.
+  # We parse in order of decreasing
+  # strictness. I.e., a very specific phrase like "January 1st, 2013" will be parsed
+  # before "January 1st," which will be parsed before just "2013". Whenever we
+  # determine a phrase is part of a date, we remove the phrase after parsing.
+  # So in the example "January 1st, 2013" we'll return only one date.
   #
-  # ==== Examples
+  # If no dates are found, returns an empty array.
   #
-  #    text = "Henry and Hanke created a calendar that causes each day to fall " +
-  #           "on the same day of the week every year. They recommend its " +
-  #           "implementation on January 1, 2018, a Monday."
-  #    creation_date = Date.parse("July 6, 2016")
+  # <b>parse_one_word(word, creation_date, parse_single_years)</b>: Given a single word,
+  # a string, tries to return a Date object.
   #
-  #    NaturalDateParsing.interpret_date(text, creation_date)
-  #        #=> [#<Date: 2018-01-01 ((2458120j,0s,0n),+0s,2299161j)>,
-  #             #<Date: 2016-07-11 ((2457581j,0s,0n),+0s,2299161j)>]
+  # <b>parse_two_words(words, creation_date = nil)</b>: Attempts to return a Date object
+  # given a string containing two words.
   #
-  #    NaturalDateParsing.interpret_date("No dates here!")
-  #        #=> []
+  # <b>parse_three_words(words, creation_date = nil)</b>: Given three words,
+  # attempts to return a Date object.
   #
-  #    NaturalDateParsing.interpret_date("2012", nil, true)
-  #        #=> [#<Date: 2012-01-01 ((2455928j,0s,0n),+0s,2299161j)>]
-  #
-  def NaturalDateParsing.interpret_date(
-                                        txt,
-                                        creation_date = nil,
-                                        parse_single_years = false,
-                                        parse_ambiguous_dates = true
-                                        )
-    possible_dates = []
-    txt = Utils::clean_str(txt)
-    words = txt.split(" ").map{|x| x.strip}
+  module NaturalDateParsing
+    ###############################################
+    ##
+    ## Constants
+    ##
+    # Names of days as well as common shortened versions.
+    SINGLE_DAYS = [
+                   'mon', 'tue', 'wed', 'thur', 'fri', 'sat', 'sun',
+                   'monday', 'tuesday', 'wednesday', 'thursday', 'friday',
+                   'saturday', 'sunday', 'tues'
+                  ]
+    # Phrases that denote a date relative to today (here often
+    # called the creation_date)
+    RELATIVE_DAYS = ['today', 'tomorrow', 'tonight', 'yesterday']
+    # Names of months as well as common shortened versions
+    MONTH = [
+             'jan', 'feb', 'mar', 'may', 'june', 'july', 'aug', 'sept', 'oct',
+             'nov', 'dec',
+             'january', 'february', 'march', 'april', 'august', 'september',
+             'october', 'november', 'december'
+            ]
+    # A list of numbers from [1, 31]
+    NUMERIC_DAY = ('1'..'31').to_a
+    # Numbers from [1, 31] as well as the common suffixes (such as 1st, 2nd, e.t.c.)
+    SUFFIXED_NUMERIC_DAY = [
+                             '1st', '2nd', '3rd', '4th', '5th', '6th', '7th',
+                             '8th', '9th', '10th', '11th', '12th', '13th', '14th',
+                             '15th', '16th', '17th', '18th', '19th', '20th',
+                             '21st', '22nd', '23rd','24th', '25th',
+                             '26th', '27th', '28th', '29th', '30th', '31st'
+                           ]
-    # We use the while loop, as apparently there are cases where we try to subset
-    # words despite the value of i being >= words.length - 3
-    # TODO: Figure out why the above happens. Preferably return to for loop.
-    # TODO: Cleaner way of structuring the below? I could break up the loops
-    # into single functions. Consider.
-    i = 0
+    ###############################################
+    ##
+    ## Main Parsing/Processing Function
+    ##
-    while (i <= words.length - 3) do
-      subset_words = words[i..(i+2)]
+    # Processes a given text and returns an array of probable dates contained within.
+    #
+    # ==== Description
+    #
+    # Tries to interpret dates from the given text, in order from strictest
+    # interpretation to looser interpretations. No word can be part of two
+    # different dates.
+    #
+    # Works by calling parse_three_words, parse_two_words, and parse_one_word
+    # on the text.
+    #
+    # ==== Attributes
+    #
+    # * +txt+ - The text to parse.
+    #
+    # * +creation_date+ - A Date object of when the text was created or released.
+    #   Defaults to nil, but if provided can make returned dates more accurate.
+    #
+    # * +parse_single_years+ - A boolean. If true, we interpret single numbers as
+    #   years. This is a very broad assumption, and so defaults to false.
+    #
+    # * +parse_ambiguous_dates+ - Some phrases are not necessarily dates depending
+    #   on context. For example "1st" may not refer to
+    #   the 1st of a month. This option toggles whether or not those
+    #   phrases are considered dates. Defaults to true.
+    #
+    # ==== Examples
+    #
+    #    text = "Henry and Hanke created a calendar that causes each day to fall " +
+    #           "on the same day of the week every year. They recommend its " +
+    #           "implementation on January 1, 2018, a Monday."
+    #    creation_date = Date.parse("July 6, 2016")
+    #
+    #    NaturalDateParsing.interpret_date(text, creation_date)
+    #        #=> [#<Date: 2018-01-01 ((2458120j,0s,0n),+0s,2299161j)>,
+    #             #<Date: 2016-07-11 ((2457581j,0s,0n),+0s,2299161j)>]
+    #
+    #    NaturalDateParsing.interpret_date("No dates here!")
+    #        #=> []
+    #
+    #    NaturalDateParsing.interpret_date("2012", nil, true)
+    #        #=> [#<Date: 2012-01-01 ((2455928j,0s,0n),+0s,2299161j)>]
+    #
+    def NaturalDateParsing.interpret_date(
+                                          txt,
+                                          creation_date = nil,
+                                          parse_single_years = false,
+                                          parse_ambiguous_dates = true
+                                          )
+      possible_dates = []
+      txt = Utils::clean_str(txt)
+      words = txt.split(" ").map{|x| x.strip}
-      proposed_date = parse_three_words(subset_words, creation_date)
+      # We use the while loop, as apparently there are cases where we try to subset
+      # words despite the value of i being >= words.length - 3
+      # TODO: Figure out why the above happens. Preferably return to for loop.
+      # TODO: Cleaner way of structuring the below? I could break up the loops
+      # into single functions. Consider.
+      i = 0
-      if(! proposed_date.nil?)
-        possible_dates << proposed_date
-        words = Utils::delete_at_indices(words, i..(i+2))
-        i -= 1
+      while (i <= words.length - 3) do
+        subset_words = words[i..(i+2)]
+        proposed_date = parse_three_words(subset_words, creation_date)
+        if(! proposed_date.nil?)
+          possible_dates << proposed_date
+          words = Utils::delete_at_indices(words, i..(i+2))
+          i -= 1
+        end
+        i += 1
       end
-      i += 1
-    end
-    i = 0
-    while (i <= words.length - 2) do
-      subset_words = words[i..(i+1)]
-      proposed_date = parse_two_words(subset_words, creation_date)
+      i = 0
-      if(! proposed_date.nil?)
-        possible_dates << proposed_date
-        words = Utils::delete_at_indices(words, i..(i+1))
-        i -= 1
+      while (i <= words.length - 2) do
+        subset_words = words[i..(i+1)]
+        proposed_date = parse_two_words(subset_words, creation_date)
+        if(! proposed_date.nil?)
+          possible_dates << proposed_date
+          words = Utils::delete_at_indices(words, i..(i+1))
+          i -= 1
+        end
+        i += 1
       end
-      i += 1
-    end
-    i = 0
-    while (i <= words.length - 1) do
-      subset_words = words[i]
+      i = 0
-      proposed_date = parse_one_word(subset_words,
-                                     creation_date,
-                                     parse_single_years,
-                                     parse_ambiguous_dates)
-      if(! proposed_date.nil?)
-        possible_dates << proposed_date
-        words.delete_at(i)
-        i -= 1
+      while (i <= words.length - 1) do
+        subset_words = words[i]
+        proposed_date = parse_one_word(subset_words,
+                                       creation_date,
+                                       parse_single_years,
+                                       parse_ambiguous_dates)
+        if(! proposed_date.nil?)
+          possible_dates << proposed_date
+          words.delete_at(i)
+          i -= 1
+        end
+        i += 1
       end
-      i += 1
+      return possible_dates
     end
-    return possible_dates
-  end
-  ###############################################
-  ##
-  ## Parse Cases (1 word, 2 words, 3 words)
-  ##
-  # Takes a single word and tries to return a date.
-  #
-  # If no date can be interpreted from the word, returns nil. We consider these
-  # cases:
-  # * DAY (mon, tuesday, e.t.c.)
-  # * A relative day (today, tomorrow, tonight, yesterday)
-  # * Dates of the form MM/DD
-  # * Numbers such as [1st, 31st]
-  # * MONTH (jan, february, e.t.c.)
-  # * YYYY (2012, 102. Must be enabled.)
-  # * YYYY-MM-DD, DD-MM-YYYY, MM-DD-YYYY
-  #
-  # ==== Attributes
-  #
-  # * +word+ - A String, preferably consisting of a single word.
-  #
-  # * +creation_date+ - A Date object of when the text was created or released.
-  #   Defaults to nil, but if provided can make returned dates more accurate.
-  #
-  # * +parse_single_years+ - A boolean. If true, we interpret single numbers as
-  #   years. This is a very broad assumption, and so defaults to false.
-  #
-  # * +parse_ambiguous_dates+ - Some phrases are not necessarily dates depending
-  #   on context. For example "1st" may not refer to
-  #   the 1st of a month. This option toggles whether or not those
-  #   phrases are considered dates. Defaults to true.
-  #
-  def NaturalDateParsing.parse_one_word(
-                                        word,
-                                        creation_date = nil,
-                                        parse_single_years = false,
-                                        parse_ambiguous_dates = true
-                                        )
-    if SINGLE_DAYS.include? word
-      proposed_date = Date.parse(word)
+    ###############################################
+    ##
+    ## Parse Cases (1 word, 2 words, 3 words)
+    ##
+    # Takes a single word and tries to return a date.
+    #
+    # If no date can be interpreted from the word, returns nil. We consider these
+    # cases:
+    # * DAY (mon, tuesday, e.t.c.)
+    # * A relative day (today, tomorrow, tonight, yesterday)
+    # * Dates of the form MM/DD
+    # * Numbers such as [1st, 31st]
+    # * MONTH (jan, february, e.t.c.)
+    # * YYYY (2012, 102. Must be enabled.)
+    # * YYYY-MM-DD, DD-MM-YYYY, MM-DD-YYYY
+    #
+    # ==== Attributes
+    #
+    # * +word+ - A String, preferably consisting of a single word.
+    #
+    # * +creation_date+ - A Date object of when the text was created or released.
+    #   Defaults to nil, but if provided can make returned dates more accurate.
+    #
+    # * +parse_single_years+ - A boolean. If true, we interpret single numbers as
+    #   years. This is a very broad assumption, and so defaults to false.
+    #
+    # * +parse_ambiguous_dates+ - Some phrases are not necessarily dates depending
+    #   on context. For example "1st" may not refer to
+    #   the 1st of a month. This option toggles whether or not those
+    #   phrases are considered dates. Defaults to true.
+    #
+    def NaturalDateParsing.parse_one_word(
+                                          word,
+                                          creation_date = nil,
+                                          parse_single_years = false,
+                                          parse_ambiguous_dates = true
+                                          )
-      # If we have the creation_date date, we can try to be a little smarter
-      if(! creation_date.nil?)
-        weeks_to_shift = difference_in_weeks(Date.today, creation_date)
-        proposed_date = proposed_date - (weeks_to_shift * 7)
+      if SINGLE_DAYS.include? word
+        proposed_date = Date.parse(word)
-        # Right now though, it should be within 1 week of accuracy, and either one
-        # week ahead or one week behind.
-        # The solution is pretty simple. If the proposed date
-        # is more than a week ahead of the creation date, then go back one week.
-        if proposed_date - creation_date > 7
-          proposed_date = proposed_date - 7
-        elsif proposed_date - creation_date < 0
-          proposed_date = proposed_date + 7
+        # If we have the creation_date date, we can try to be a little smarter
+        if(! creation_date.nil?)
+          weeks_to_shift = difference_in_weeks(Date.today, creation_date)
+          proposed_date = proposed_date - (weeks_to_shift * 7)
+          # Right now though, it should be within 1 week of accuracy, and either one
+          # week ahead or one week behind.
+          # The solution is pretty simple. If the proposed date
+          # is more than a week ahead of the creation date, then go back one week.
+          if proposed_date - creation_date > 7
+            proposed_date = proposed_date - 7
+          elsif proposed_date - creation_date < 0
+            proposed_date = proposed_date + 7
+          end
         end
+        return proposed_date
       end
-      return proposed_date
-    end
-    # Parsing phrases like "yesterday", "today", "tonight"
-    if RELATIVE_DAYS.include? word
-      if word == 'today' || word == 'tonight'
-        if creation_date.nil?
-          return Date.today
-        else
-          return creation_date
+      # Parsing phrases like "yesterday", "today", "tonight"
+      if RELATIVE_DAYS.include? word
+        if word == 'today' || word == 'tonight'
+          if creation_date.nil?
+            return Date.today
+          else
+            return creation_date
+          end
+        elsif word == 'yesterday'
+          if creation_date.nil?
+            return Date.today - 1
+          else
+            return creation_date - 1
+          end
+        elsif word == "tomorrow"
+          return creation_date + 1
         end
-      elsif word == 'yesterday'
-        if creation_date.nil?
-          return Date.today - 1
-        else
-          return creation_date - 1
-        end
-      elsif word == "tomorrow"
-        return creation_date + 1
       end
+      # Parsing strings of the form XX/XX
+      if word.include? '/'
+        return slash_date(word, creation_date)
+      end
+      # Parsing strings like "23rd"
+      if (SUFFIXED_NUMERIC_DAY.include? word) && parse_ambiguous_dates
+        return numeric_single_day(word, creation_date)
+      end
+      # Parsing month names
+      if MONTH.include? word
+        return default_month(word, creation_date)
+      end
+      # In this case, we assume it's a year!
+      if parse_single_years && (Utils::is_int? word)
+        return default_year(word)
+      end
+      # Parsing XX-XX-XXXX or XXXX-XX-XX
+      if full_numeric_date?(word)
+        return full_numeric_date(word)
+      end
     end
-    # Parsing strings of the form XX/XX
-    if word.include? '/'
-      return slash_date(word, creation_date)
-    end
-    # Parsing strings like "23rd"
-    if (SUFFIXED_NUMERIC_DAY.include? word) && parse_ambiguous_dates
-      return numeric_single_day(word, creation_date)
+    # Takes two words and tries to return a date.
+    #
+    # If no date can be interpreted from the word, returns nil. In this case,
+    # we look for dates of this form:
+    # * MONTH DAY
+    #
+    # ==== Attributes
+    #
+    # * +words+ - An array of two words, downcased and stripped.
+    #
+    # * +creation_date+ - A Date object of when the text was created or released.
+    #   Defaults to nil, but if provided can make returned dates more accurate.
+    #
+    def NaturalDateParsing.parse_two_words(words, creation_date = nil)
+      if MONTH.include?(words[0]) && _weak_day?(words[1])
+        return month_day(words, creation_date)
+      end
     end
-    # Parsing month names
-    if MONTH.include? word
-      return default_month(word, creation_date)
-    end
-    # In this case, we assume it's a year!
-    if parse_single_years && (Utils::is_int? word)
-      return default_year(word)
+    # Takes three words and tries to return a date.
+    #
+    # If no date can be interpreted from the word, returns nil. In this case,
+    # assumes the word can take these forms:
+    # * MONTH DAY YEAR
+    #
+    # ==== Attributes
+    #
+    # * +words+ - An array of three words, downcased and stripped.
+    #
+    # * +creation_date+ - A Date object of when the text was created or released.
+    #   Defaults to nil, but if provided can make returned dates more accurate.
+    #
+    def NaturalDateParsing.parse_three_words(words, creation_date = nil)
+      if MONTH.include?(words[0]) && _weak_day?(words[1]) && Utils::is_int?(words[2])
+        return Date.parse(words.join(" "))
+      end
     end
-    # Parsing XX-XX-XXXX or XXXX-XX-XX
-    if full_numeric_date?(word)
-      return full_numeric_date(word)
-    end
+    ###############################################
+    ##
+    ## Parse Functions
+    ##
-  end
-  # Takes two words and tries to return a date.
-  #
-  # If no date can be interpreted from the word, returns nil. In this case,
-  # we look for dates of this form:
-  # * MONTH DAY
-  #
-  # ==== Attributes
-  #
-  # * +words+ - An array of two words, downcased and stripped.
-  #
-  # * +creation_date+ - A Date object of when the text was created or released.
-  #   Defaults to nil, but if provided can make returned dates more accurate.
-  #
-  def NaturalDateParsing.parse_two_words(words, creation_date = nil)
-    if MONTH.include?(words[0]) && _weak_day?(words[1])
-      return month_day(words, creation_date)
+    # Given a single word, assumes the word is of the form XX/XX and returns
+    # the appropriate Date object. If not possible, returns nil.
+    def NaturalDateParsing.slash_date(word, creation_date = nil)
+      samp = word.split('/')
+      month = samp[0].to_i
+      day = samp[1].to_i
+      if month > 0 && month <= 12 && day > 0 && day <= 31
+        # TODO: IMPROVE EXCEPTION HANDLING.
+        begin
+          proposed_date = Date.parse(word)
+          if(! creation_date.nil?) ## We're sensitive to only years here.
+            years_diff = Date.today.year - creation_date.year
+            proposed_date = proposed_date << (12 * years_diff)
+          end
+          return proposed_date
+        rescue ArgumentError
+          return nil
+        end
+      end
     end
-  end
-  # Takes three words and tries to return a date.
-  #
-  # If no date can be interpreted from the word, returns nil. In this case,
-  # assumes the word can take these forms:
-  # * MONTH DAY YEAR
-  #
-  # ==== Attributes
-  #
-  # * +words+ - An array of three words, downcased and stripped.
-  #
-  # * +creation_date+ - A Date object of when the text was created or released.
-  #   Defaults to nil, but if provided can make returned dates more accurate.
-  #
-  def NaturalDateParsing.parse_three_words(words, creation_date = nil)
-    if MONTH.include?(words[0]) && _weak_day?(words[1]) && Utils::is_int?(words[2])
-      return Date.parse(words.join(" "))
+    # Parses an array containing two elements (single words) on the assumption
+    # that the array is of the form ["MONTH", "DAY"]
+    def NaturalDateParsing.month_day(words, creation_date = nil)
+      begin
+        proposed_date = Date.parse(words.join(" "))
+        diff_in_years = creation_date.nil? ? 0 : (creation_date.year - Date.today.year)
+        return proposed_date >> diff_in_years * 12
+      rescue ArgumentError
+        return nil
+      end
     end
-  end
-  ###############################################
-  ##
-  ## Parse Functions
-  ##
-  # Given a single word, assumes the word is of the form XX/XX and returns
-  # the appropriate Date object. If not possible, returns nil.
-  def NaturalDateParsing.slash_date(word, creation_date = nil)
-    samp = word.split('/')
-    month = samp[0].to_i
-    day = samp[1].to_i
-    if month > 0 && month <= 12 && day > 0 && day <= 31
-      # TODO: IMPROVE EXCEPTION HANDLING.
+    # Parses a single numeric date (1st, 2nd, 3rd, e.t.c.).
+    def NaturalDateParsing.numeric_single_day(word, creation_date = nil)
+      diff_in_months = creation_date.nil? ? 0 : (creation_date.year * 12 + creation_date.month) -
+                                                (Date.today.year * 12 + Date.today.month)
       begin
-        proposed_date = Date.parse(word)
-        if(! creation_date.nil?) ## We're sensitive to only years here.
-          years_diff = Date.today.year - creation_date.year
-          proposed_date = proposed_date << (12 * years_diff)
-        end
-        return proposed_date
+        return Date.parse(word) >> diff_in_months
       rescue ArgumentError
+        ## If an ArgumentError arises, Date is not convinced it's a date.
         return nil
       end
     end
-  end
-  # Parses an array containing two elements (single words) on the assumption
-  # that the array is of the form ["MONTH", "DAY"]
-  def NaturalDateParsing.month_day(words, creation_date = nil)
-    begin
-      proposed_date = Date.parse(words.join(" "))
+    # Parses a single word of the form XXXX-XX-XX, DD-MM-YYYY or MM-DD-YYYY
+    def NaturalDateParsing.full_numeric_date(word)
+      subparts = word.split("-")
+      # This is a weak check to see where the year is
+      year_index = (subparts[0].to_i).abs > 31 ? 0 : 2
-      diff_in_years = creation_date.nil? ? 0 : (creation_date.year - Date.today.year)
+      # Then we assume it's of the form YYYY-MM-DD
+      if year_index == 0
+        return Date.parse(word)
+      else
+        # We check the subparts to try to see which part is DD.
+        # If we can't determine it, we assume it's International Standard Format,
+        # or DD-MM-YY
+        if subparts[1].to_i > 12
+          # American Standard (MM-DD-YYYY)
+          subparts[0] = numeric_month_to_string(subparts[0].to_i)
+          return Date.parse(subparts.join(" "))
+        else
+          # International Standard (DD-MM-YYYY)
+          return Date.parse(word)
+        end
+      end
-      return proposed_date >> diff_in_years * 12
-    rescue ArgumentError
-      return nil
+      return Date.parse(word)
     end
-  end
-  # Parses a single numeric date (1st, 2nd, 3rd, e.t.c.).
-  def NaturalDateParsing.numeric_single_day(word, creation_date = nil)
-    diff_in_months = creation_date.nil? ? 0 : (creation_date.year * 12 + creation_date.month) -
-                                              (Date.today.year * 12 + Date.today.month)
-    begin
-      return Date.parse(word) >> diff_in_months
-    rescue ArgumentError
-      ## If an ArgumentError arises, Date is not convinced it's a date.
-      return nil
+    private
+    ##############################################
+    ##
+    ## Private Functions
+    ##
+    def NaturalDateParsing._weak_day?(word)
+      return (NUMERIC_DAY.include? word) || (SUFFIXED_NUMERIC_DAY.include? word)
     end
-  end
-  # Parses a single word of the form XXXX-XX-XX, DD-MM-YYYY or MM-DD-YYYY
-  def NaturalDateParsing.full_numeric_date(word)
-    subparts = word.split("-")
-    # This is a weak check to see where the year is
-    year_index = (subparts[0].to_i).abs > 31 ? 0 : 2
+    def NaturalDateParsing.default_year(year)
+      return Date.parse("Jan 1 " + year)
+    end
-    # Then we assume it's of the form YYYY-MM-DD
-    if year_index == 0
-      return Date.parse(word)
-    else
-      # We check the subparts to try to see which part is DD.
-      # If we can't determine it, we assume it's International Standard Format,
-      # or DD-MM-YY
+    ## TODO. NOT SENSITIVE TO YEAR.
+    def NaturalDateParsing.default_month(month, released = nil)
+      this_year = released.nil? ? Date.today.year : released.year
+      return Date.parse(month + " " + this_year.to_s)
+    end
+    def NaturalDateParsing.suffix(number)
+      int = number.to_i
-      if subparts[1].to_i > 12
-        # American Standard (MM-DD-YYYY)
-        subparts[0] = numeric_month_to_string(subparts[0].to_i)
-        return Date.parse(subparts.join(" "))
+      ## Check to see if the least significant digit is 1.
+      if int & 1 == 1
+        return int.to_s + "st"
       else
-        # International Standard (DD-MM-YYYY)
-        return Date.parse(word)
+        return int.to_s + "th"
       end
     end
-    return Date.parse(word)
-  end
-  private
-  ##############################################
-  ##
-  ## Private Functions
-  ##
-  def NaturalDateParsing._weak_day?(word)
-    return (NUMERIC_DAY.include? word) || (SUFFIXED_NUMERIC_DAY.include? word)
-  end
-  def NaturalDateParsing.default_year(year)
-    return Date.parse("Jan 1 " + year)
-  end
-  ## TODO. NOT SENSITIVE TO YEAR.
-  def NaturalDateParsing.default_month(month, released = nil)
-    this_year = released.nil? ? Date.today.year : released.year
-    return Date.parse(month + " " + this_year.to_s)
-  end
-  def NaturalDateParsing.suffix(number)
-    int = number.to_i
-    ## Check to see if the least significant digit is 1.
-    if int & 1 == 1
-      return int.to_s + "st"
-    else
-      return int.to_s + "th"
+    ## Be careful with this.
+    ## date1 is the later date.
+    def NaturalDateParsing.difference_in_weeks(date1, date2)
+      return ((date1 - date2) / 7).to_i
     end
-  end
-  ## Be careful with this.
-  ## date1 is the later date.
-  def NaturalDateParsing.difference_in_weeks(date1, date2)
-    return ((date1 - date2) / 7).to_i
-  end
-  # Is it of the form XXXX-XX-XX?
-  def NaturalDateParsing.full_numeric_date?(word)
-    output = true
-    if word.include? "-"
-      substrings = word.split("-")
-      for substring in substrings do
-        output = output && Utils.is_int?(substring)
+    # Is it of the form XXXX-XX-XX?
+    def NaturalDateParsing.full_numeric_date?(word)
+      output = true
+      if word.include? "-"
+        substrings = word.split("-")
+        for substring in substrings do
+          output = output && Utils.is_int?(substring)
+        end
+      else
+        output = false
       end
-    else
-      output = false
+      return output
     end
-    return output
-  end
-  def NaturalDateParsing.numeric_month_to_string(numeric)
-    months = ["january", "february", "march", "april", "may", "june",
-              "july", "august", "september", "october", "november",
-              "december"]
+    def NaturalDateParsing.numeric_month_to_string(numeric)
+      months = ["january", "february", "march", "april", "may", "june",
+                "july", "august", "september", "october", "november",
+                "december"]
+      return months[numeric - 1]
+    end
-    return months[numeric - 1]
   end
 end

data/lib/date_parser/utils.rb CHANGED Viewed

@@ -1,51 +1,55 @@
-# Extra utility functions for broader use in the gem.
-module Utils
-  # Determine whether or not a String is a base 10 integer.
-  def Utils.is_int?(str)
-    str.to_i.to_s == str || strong_is_int?(str)
-  end
+module DateParser
-  # A more rigorous check to see if the String is an int.
-  def Utils.strong_is_int?(str)
-    nums = ("0".."9").to_a
+  # Extra utility functions for broader use in the gem.
+  #
+  module Utils
-    for char in str.each_char do
-      if ! nums.include? char
-        return false
+    # Determine whether or not a String is a base 10 integer.
+    def Utils.is_int?(str)
+      str.to_i.to_s == str || strong_is_int?(str)
+    end
+    # A more rigorous check to see if the String is an int.
+    def Utils.strong_is_int?(str)
+      nums = ("0".."9").to_a
+      for char in str.each_char do
+        if ! nums.include? char
+          return false
+        end
       end
+      return true
     end
-    return true
-  end
-  # Removes punctuation.
-  def Utils.clean_out_punctuation(str)
-    str.gsub(/[^a-z0-9\s\/-]/i, '')
-  end
-  # Removes punctuation and downcases the str.
-  def Utils.clean_str(str)
-    clean_out_punctuation(str).downcase
-  end
-  # Performs delete_at for a range of integers
-  #
-  # Assumes that the integers in range are contiguous, and sorted in ascending
-  # order.
-  def Utils.delete_at_indices(array, range)
-    first_val = range.first
-    for _ in range do
-      array.delete_at(first_val)
+    # Removes punctuation.
+    def Utils.clean_out_punctuation(str)
+      str.gsub(/[^a-z0-9\s\/-]/i, '')
     end
-    return array
-  end
-  # Checks to see if an object is descended from an ancestor (or is the ancestor)
-  # nil_accepted is a flag that checks
-  def Utils.descended_from?(obj, ancestor, nil_accepted = true)
-    return obj.nil? ? nil_accepted : obj.class.ancestors.include?(ancestor)
+    # Removes punctuation and downcases the str.
+    def Utils.clean_str(str)
+      clean_out_punctuation(str).downcase
+    end
+    # Performs delete_at for a range of integers
+    #
+    # Assumes that the integers in range are contiguous, and sorted in ascending
+    # order.
+    def Utils.delete_at_indices(array, range)
+      first_val = range.first
+      for _ in range do
+        array.delete_at(first_val)
+      end
+      return array
+    end
+    # Checks to see if an object is descended from an ancestor (or is the ancestor)
+    # nil_accepted is a flag that checks
+    def Utils.descended_from?(obj, ancestor, nil_accepted = true)
+      return obj.nil? ? nil_accepted : obj.class.ancestors.include?(ancestor)
+    end
   end
 end

data/lib/spec/natural_date_parsing_spec.rb CHANGED Viewed

@@ -1,6 +1,6 @@
 require_relative "../date_parser"
-describe NaturalDateParsing do
+describe DateParser::NaturalDateParsing do
   #########################################################
   ##
@@ -25,26 +25,26 @@ describe NaturalDateParsing do
   describe ".interpret_date" do
     context "given 'April 6th, 2014'" do
       it "returns Sun, 06 Apr 2014 as a date object" do
-        expect(NaturalDateParsing::interpret_date(@date)).to eql(@parsed_date)
+        expect(DateParser::NaturalDateParsing::interpret_date(@date)).to eql(@parsed_date)
       end
     end
     context "given a sentence containing April 6th, 2014" do
       it "returns Sun, 06 Apr 2014 as a date object" do
-        expect(NaturalDateParsing::interpret_date(@text)).to eql(@parsed_date)
+        expect(DateParser::NaturalDateParsing::interpret_date(@text)).to eql(@parsed_date)
       end
     end
     context "given a paragraph containing several dates" do
       it "returns a list of all dates mentioned in the paragraph" do
-        expect(NaturalDateParsing::interpret_date(@paragraph)).to eql(@parsed_date_paragraph)
+        expect(DateParser::NaturalDateParsing::interpret_date(@paragraph)).to eql(@parsed_date_paragraph)
       end
     end
   end
 end
-describe NaturalDateParsing do
+describe DateParser::NaturalDateParsing do
   #########################################################
   ##
@@ -62,7 +62,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("February 27, 1844")]
       it "captures the single date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -72,7 +72,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("July 4th, 2016")]
       it "correctly uses the creation_date parameter" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -82,7 +82,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("February 12, 1994")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -92,7 +92,7 @@ describe NaturalDateParsing do
       answer = [Date.today - 1]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -102,7 +102,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("January 11, 1994")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -113,7 +113,7 @@ describe NaturalDateParsing do
       parse_single_years = true
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date, parse_single_years)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date, parse_single_years)).to eql(answer)
       end
     end
@@ -123,7 +123,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("March 4, 2004")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -131,7 +131,7 @@ describe NaturalDateParsing do
 end
-describe NaturalDateParsing do
+describe DateParser::NaturalDateParsing do
   #########################################################
   ##
@@ -148,7 +148,7 @@ describe NaturalDateParsing do
       parse_single_years = true
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date, parse_single_years)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date, parse_single_years)).to eql(answer)
       end
     end
@@ -172,7 +172,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("August 25, 2013")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -184,7 +184,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("March 14, 1933")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -195,7 +195,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("July 4, 2016")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -205,7 +205,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("October 3, 2016")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -218,7 +218,7 @@ describe NaturalDateParsing do
                 Date.parse("July 11, 2016")] # Reconsider
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -228,7 +228,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("September 4, 1981")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -240,7 +240,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("January 1st, 2016")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end
@@ -252,7 +252,7 @@ describe NaturalDateParsing do
       answer = [Date.parse("June 8, 2016")]
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
       end
     end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: date_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.32
+  version: 0.1.41
 platform: ruby
 authors:
 - Ryan Kwon
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-09-25 00:00:00.000000000 Z
+date: 2016-10-10 00:00:00.000000000 Z
 dependencies: []
 description: DateParser is a simple, fast, and effective way to parse dates from natural
   language text.
@@ -22,7 +22,6 @@ files:
 - NEWS.md
 - README.md
 - lib/date_parser.rb
-- lib/date_parser/date_utils.rb
 - lib/date_parser/natural_date_parsing.rb
 - lib/date_parser/utils.rb
 - lib/spec/date_parser_spec.rb

data/lib/date_parser/date_utils.rb DELETED Viewed

File without changes