date_parser 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83fcce6dfc6821ee2701b10b33bb9cead5aa05e7
-  data.tar.gz: 47922dd354451a884c45e02f0fd818f359aef78c
+  metadata.gz: 49515560a749346476e3439e00f22696efe24e6c
+  data.tar.gz: 5b62496f4a460f5de51309ed666248013bffc00e
 SHA512:
-  metadata.gz: 405f093a43e736aef635c60ca99655f891a42c9308d4da053e3a7aaa9cd9a8edabb93f2c1fa590141f87d289e80a348ab620468a35ef1433eeb16ef7819cd130
-  data.tar.gz: 4ce37b863c5901b1f4ddaa0bd68792f40f64cd3649e715d64dd7af49a6e6884088348487a3b76763b80f22380d2473a3eb1c2340105b553a77702e830604ef6d
+  metadata.gz: 04d19e1cb3d309af0e6a840392fbf888770db7badd423c5bfdb1887a8d34717b37e974f7a3cf01500cabb0a338fb77faf36c7453be253b71acde2d28905fbd39
+  data.tar.gz: c246d93f41261c4417eeb49b7b6544ddb1c8f8b70bc7d2892ac341292fecc86e44ece6ee4f507b7aa0c16126c29a79dd907f057edc6e97115142019c2d553c82

data/NEWS.md

@@ -1,3 +1,16 @@
+# DateParser 0.1.3
+* New internal checks to avoid ambiguous behavior.
+    + Notably: creation_date is enforced to be a descendent of the Date class.
+* New tests to ensure that the program fails when unexpected types are passed in.
+
+# DateParser 0.1.2
+* New option: `parse_ambiguous_dates` flag, which determines whether or not some 
+looser phrases are considered dates.
+* Documentation fixes and format improvements.
+* Added more test cases to cover options in `parse`.
+* Restructured test files.
+* `parse` option defaults now work in all cases.
+
 # DateParser 0.1.1
 * Critical bug fix - Helper files now sent with the gem.
 

data/README.md

@@ -1,14 +1,14 @@
 # DateParser
 
 DateParser is a simple, fast, effective way of parsing dates from natural language
-text in a flexible way.
+text.
 
 # Installation
 ```
 $ gem install date_parser
 ```
 
-# Usage
+# Examples
 ```ruby
 require 'date_parser'
 
@@ -35,15 +35,6 @@ DateParser::parse(text, creation_date).to_s
     #=> [#<Date: 1994-01-11 ((2449364j,0s,0n),+0s,2299161j)>]
 
 
-text = "The first time I asked someone on a date, I was in Iowa, it was a " +
-       "winterly mid-month January, we were to go to finding nemo, I was 9, and " +
-       "although she was interested, her parents said no."
-creation_date = Date.parse("July 6, 2016")
-
-DateParser::parse(text, creation_date).to_s
-    #=> [#<Date: 2016-01-01 ((2457389j,0s,0n),+0s,2299161j)>]
-
-
 text = "7-24-2015"
 DateParser::parse(text).to_s
     #=> [#<Date: 2015-07-24 ((2457228j,0s,0n),+0s,2299161j)>]
@@ -97,10 +88,12 @@ DateParser::parse("No dates here",
     #=> [#<Date: 2016-01-01 ((2457389j,0s,0n),+0s,2299161j)>]
 ```
 
-# Examples
+# Usage
 
 DateParser has just one function: `parse(txt, creation_date, opts)`, which
-always returns an array with Date elements parsed from the text.
+always returns an array with Date elements parsed from the text. If DateParser
+can't find any dates, it'll return an empty array (or an array containing just
+the `nil_date`, if you define that!)
 
 `parse` is case-insensitive, robust to crazy punctuation and spacing, and will 
 try to interpret dates in the strictest possible way before trying to find 
@@ -119,7 +112,10 @@ to the `creation_date`.
 * `unique`: (boolean) Return only unique dates in the output array.
 * `nil_date`: (Date) If no dates are found, instead of returning an empty array,
 return an array containing only `nil_date`.
-* `parse_single_years`: (boolean) Should the parser interpret integers as years?
+* `parse_single_years`: (boolean) Interpret integers as years.
+* `parse_ambiguous_dates`: (boolean) 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.
 
 # Requests or Bugs?
 Leave an issue on this Github page! I'll most likely get back to you within 24

data/lib/date_parser.rb

@@ -17,14 +17,24 @@ module DateParser
   # ==== 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.
+  #   Defaults to nil, but if provided can make returned dates more accurate.
+  #   This is intentionally checked to be a Date object, as other data types
+  #   may cause unforeseen behavior.
   #
   # ==== Options
   #
   # * +:unique+ - Return only unique Date objects. Defaults to false
+  #
   # * +:nil_date+ - A date to return if no dates are parsed. Defaults to nil.
-  # * +:parse_single_years+ - Should we parse single ints as years? Defaults to false.
+  #
+  # * +:parse_single_years+ - Parse single ints as years. 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
   #
@@ -57,14 +67,28 @@ module DateParser
   #    DateParser::parse("No dates here", nil, nil_date: Date.parse("Jan 1 2012"))
   #        #=> [#<Date: 2012-01-01 ((2455928j,0s,0n),+0s,2299161j)>]
   #
+  #    creation_date = Date.parse("July 15, 2016")
+  #    DateParser::parse("He was 1st!", creation_date)
+  #        #=> [#<Date: 2016-07-01 ((2457571j,0s,0n),+0s,2299161j)>]
+  #
+  #    DateParser::parse("He was 1st!", creation_date, parse_ambiguous_dates: false)
+  #        #=> []
+  #
   def DateParser.parse(txt, creation_date = nil, opts = {})
-    unique = opts[:unique] || false
-    nil_date = opts[:nil_date] || nil
-    parse_single_years = opts[:parse_single_years] || false
+    unique = opts[:unique].nil? ? false : opts[:unique]
+    nil_date = opts[:nil_date].nil? ? nil : opts[:nil_date]
+    parse_single_years = opts[:parse_single_years].nil? ? false : opts[:parse_single_years]
+    parse_ambiguous_dates = opts[:parse_ambiguous_dates].nil? ? true : opts[:parse_ambiguous_dates]
+    
+    if ! Utils::descended_from?(creation_date, Date)
+      raise ArgumentError, "creation_date must be a descendent of the Date class." +
+                           "Otherwise, ambiguous behavior may result."
+    end
     
     interpreted_dates = NaturalDateParsing::interpret_date(txt, 
                                                            creation_date, 
-                                                           parse_single_years)
+                                                           parse_single_years,
+                                                           parse_ambiguous_dates)
     
     if unique
       interpreted_dates.uniq!

data/lib/date_parser/natural_date_parsing.rb

@@ -77,10 +77,17 @@ module NaturalDateParsing
   # ==== 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.
+  #   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.
+  #   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
   #
@@ -102,7 +109,8 @@ module NaturalDateParsing
   def NaturalDateParsing.interpret_date(
                                         txt, 
                                         creation_date = nil, 
-                                        parse_single_years = false
+                                        parse_single_years = false,
+                                        parse_ambiguous_dates = true
                                         )
     possible_dates = []
     txt = Utils::clean_str(txt)
@@ -149,7 +157,10 @@ module NaturalDateParsing
     while (i <= words.length - 1) do
       subset_words = words[i]
       
-      proposed_date = parse_one_word(subset_words, creation_date, parse_single_years)
+      proposed_date = parse_one_word(subset_words, 
+                                     creation_date, 
+                                     parse_single_years,
+                                     parse_ambiguous_dates)
       
       if(! proposed_date.nil?)
         possible_dates << proposed_date
@@ -184,15 +195,23 @@ module NaturalDateParsing
   # ==== 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.
+  #   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.
+  #   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_single_years = false,
+                                        parse_ambiguous_dates = true
                                         )
     
     if SINGLE_DAYS.include? word
@@ -243,7 +262,7 @@ module NaturalDateParsing
     end
     
     # Parsing strings like "23rd"
-    if SUFFIXED_NUMERIC_DAY.include? word
+    if (SUFFIXED_NUMERIC_DAY.include? word) && parse_ambiguous_dates
       return numeric_single_day(word, creation_date)
     end
     
@@ -274,8 +293,9 @@ module NaturalDateParsing
   # ==== 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.
+  #   Defaults to nil, but if provided can make returned dates more accurate.
   #
   def NaturalDateParsing.parse_two_words(words, creation_date = nil)
     
@@ -295,8 +315,9 @@ module NaturalDateParsing
   # ==== 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.
+  #   Defaults to nil, but if provided can make returned dates more accurate.
   #
   def NaturalDateParsing.parse_three_words(words, creation_date = nil)
 

data/lib/date_parser/utils.rb

@@ -31,6 +31,9 @@ module Utils
   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
@@ -39,4 +42,10 @@ module Utils
     
     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

data/lib/spec/date_parser_spec.rb

@@ -1,300 +1,167 @@
 require_relative "../date_parser"
 
-## Run this file with this command:
-## rspec lib/spec/date_parser_spec.rb
-
-describe NaturalDateParsing do
+describe DateParser do
   
   #########################################################
   ##
-  ## Basic Mechanics Testing
+  ## Options Testing
   ##
-  
-  before do
-    
-    @date = "April 6th, 2014"
-    @text = "Remember to meet me on April 6th, 2014, alright?"
-    @paragraph = "April 6th, 2014 isn't good for me. We should meet instead on\n" +
-                 "February 4th, 2013. Or even March 31st, 2017. No rush."
-    
-    @parsed_date = [Date.parse("April 6th, 2014")]
-    @parsed_date_paragraph = [
-                              Date.parse("April 6th, 2014"),
-                              Date.parse("February 4th, 2013"),
-                              Date.parse("March 31st, 2017")
-                              ]
-  end
-  
-  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)
-      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)
-      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)
-      end
-    end
-  end
-end
-
-
-describe NaturalDateParsing do
-  
-  #########################################################
-  ##
-  ## Edge Cases. More Colloquial Language. More complicated phrases.
-  ##
-  
-  describe ".interpret_date" do
+  # * +:parse_single_years+ - Parse single ints as years. 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.
+  describe ".parse" do
     
-    context "Given a longer sentence containing a date" do
-      text = "La Puerta del Conde (The Count's Gate) is the site in Santo" + 
-        "Domingo, Dominican Republic where Francisco del Rosario Sánchez, one of the" + 
-        "Dominican Founding Fathers, proclaimed Dominican independence and raised the" + 
-        "first Dominican Flag, on February 27, 1844."
-      creation_date = nil
-      answer = [Date.parse("February 27, 1844")]
+    context "Not using unique option" do
+      text = "Sunday, Sunday, Sunday!"
+      creation_date = Date.parse("July 15, 2016")
+      answer = [Date.parse("July 17, 2016"), 
+                Date.parse("July 17, 2016"), 
+                Date.parse("July 17, 2016")]
       
-      it "captures the single date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      it "correctly gets repeated dates" do
+        expect(DateParser::parse(text, creation_date, unique: false)).to eql(answer)
       end
     end
     
-    context "Colloquial use of date 1" do
-      text = "We should go on the 4th if we can."
-      creation_date = Date.parse("July 1st 2016")
-      answer = [Date.parse("July 4th, 2016")]
+    context "Using unique option" do
+      text = "Sunday, Sunday, Sunday!"
+      creation_date = Date.parse("July 15, 2016")
+      answer = [Date.parse("July 17, 2016")]
       
-      it "correctly uses the creation_date parameter" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      it "correctly gets only unique dates" do
+        expect(DateParser::parse(text, creation_date, unique: true)).to eql(answer)
       end
     end
     
-    context "Correct use of XX/XX format 1" do
-      text = "Newsflash: things happen on 02/12!"
-      creation_date = Date.parse("January 1st, 1994")
-      answer = [Date.parse("February 12, 1994")]
+    context "Using nil date option" do
+      text = "No dates"
+      creation_date = Date.parse("July 15, 2016")
+      nil_date = Date.parse("July 17, 2016")
+      answer = [Date.parse("July 17, 2016")]
       
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      it "correctly returns the nil_date" do
+        expect(DateParser::parse(text, creation_date, nil_date: nil_date)).to eql(answer)
       end
     end
     
-    context "Given yesterday" do
-      text = "Yesterday was certainly a day."
-      creation_date = nil
-      answer = [Date.today - 1]
+    context "Using the parse_single_years option" do
+      text = "2000"
+      creation_date = Date.parse("July 15, 2016")
+      answer = [Date.parse("January 1, 2000")]
       
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      it "correctly parses ints as years" do
+        expect(DateParser::parse(text, creation_date, parse_single_years: true)).to eql(answer)
       end
     end
     
-    context "Given yesterday with a creation_date date" do
-      text = "Yesterday was certainly a day."
-      creation_date = Date.parse("January 12, 1994")
-      answer = [Date.parse("January 11, 1994")]
+    context "Setting the parse_ambiguous_dates option to false" do
+      text = "He was 1st!"
+      creation_date = Date.parse("July 15, 2016")
+      answer = []
       
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      it "ignores ambiguous phrases" do
+        expect(DateParser::parse(text, creation_date, parse_ambiguous_dates: false)).to eql(answer)
       end
     end
     
-    context "Single year is correctly parsed" do
-      text = "In 1492 Columbus sailed the ocean blue."
-      creation_date = nil
-      answer = [Date.parse("January 1, 1492")]
-      parse_single_years = true
+    context "Setting unique and parse_single_years" do
+      text = "12 20 32 402 20"
+      creation_date = Date.parse("July 15, 2016")
+      answer = [Date.parse("January 1, 12"),
+                Date.parse("January 1, 20"),
+                Date.parse("January 1, 32"),
+                Date.parse("January 1, 402")]
       
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date, parse_single_years)).to eql(answer)
+      it "Returns unique dates and parses ints as years." do
+        expect(DateParser::parse(text, creation_date, unique: true, parse_single_years: true)).to eql(answer)
       end
     end
-    
-    context "Correctly parses month and day in middle of sentence" do
-      text = "Something something something march 4 something something"
-      creation_date = Date.parse("Jan 1, 2004")
-      answer = [Date.parse("March 4, 2004")]
-      
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
-      end
-    end
-    
   end
-end
-
-
-describe NaturalDateParsing do
   
   #########################################################
   ##
-  ## Colloquial Language samples from volunteers
+  ## Edge Cases
   ##
   
-  describe ".interpret_date" do
-    
-    context "Colloquial example 1" do
-      text = "Charlie Chaplin and Jason Earles (Hannah Montana's brother) were " +
-      "alive at the same time for eight months in 1977"
-      creation_date = Date.parse("July 6, 2016")
-      answer = [Date.parse("January 1, 1977")]
-      parse_single_years = true
-      
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date, parse_single_years)).to eql(answer)
-      end
-    end
-    
-    ## Stopping this test for right now. Hard to tell which April.
-    ## Ambiguous in the general case.
-    #context "Colloquial example 2" do
-    #  text = "For a job I started this April, I had to parse dates of various " +
-    #  "formats, such as MM-DD-YY, MM/YYYY, and YY-MM-DD. It was infuriating, " +
-    #  "and what I assume you to be doing reminds me of this."
-    #  creation_date = Date.parse("July 6, 2016")
-    #  answer = [Date.parse("April 1, 2016")] ## Reconsider
-    #  
-    #  it "correctly grabs the date" do
-    #    expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
-    #  end
-    #end
-    
-    context "Colloquial example 3" do
-      text = "August 25, 2013, I met So-and-So"
-      creation_date = Date.parse("July 6, 2016")
-      answer = [Date.parse("August 25, 2013")]
-      
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
-      end
-    end
-    
-    context "Colloquial example 4" do
-      text = "Quincy Jones (producer of Thriller) and Michael Caine (veteran " +
-      "British actor) were both born on the same day and the same hour on March " +
-      "14, 1933. They are still friends to this day."
-      creation_date = Date.parse("July 6, 2016")
-      answer = [Date.parse("March 14, 1933")]
-      
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
-      end
-    end
-    
-    context "Colloquial example 5" do
-      text = "Two days ago (July 4, 2016) was the 190th death anniversary of " +
-      "the second and third US Presidents: John Adams and Thomas Jefferson, who died 5 hours apart."
-      creation_date = Date.parse("July 6, 2016")
-      answer = [Date.parse("July 4, 2016")]
-      
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
-      end
-    end
-    
-    context "Colloquial example 6" do
-      text = "On October 3rd So-and-So asked me what day it was"
-      creation_date = Date.parse("July 6, 2016")
-      answer = [Date.parse("October 3, 2016")]
-      
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
-      end
-    end
-    
-    context "Colloquial example 7" do
-      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")
-      answer = [Date.parse("January 1, 2018"),
-                Date.parse("July 11, 2016")] # Reconsider
-      
-      it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
-      end
-    end
-    
-    context "Colloquial example 8" do
-      text = "Beyoncé Giselle Knowles-Carter was born on September 4, 1981."
-      creation_date = Date.parse("July 6, 2016")
-      answer = [Date.parse("September 4, 1981")]
+  describe ".parse" do
+    context "Parse fully numeric date" do
+      text = "2012-02-12"
+      answer = [Date.parse("2012-02-12")]
       
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::parse(text)).to eql(answer)
       end
     end
     
-    context "Colloquial example 9" do
-      text = "The first time I asked someone on a date, I was in Iowa, it was a " +
-      "winterly mid-month January, we were to go to finding nemo, I was 9, and " +
-      "although she was interested, her parents said no."
-      creation_date = Date.parse("July 6, 2016")
-      answer = [Date.parse("January 1st, 2016")]
+    context "Parse American fully numeric date" do
+      text = "7-24-2015"
+      answer = [Date.parse("July 24, 2015")]
       
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::parse(text)).to eql(answer)
       end
     end
     
-    context "Colloquial example 10" do
-      text = "You ate 10 dates from a crate of dates that were picked on June " +
-      "8th from a date tree that was cultivated one score and three years ago. " +
-      "Good luck parsing through the antics of my semantics."
-      creation_date = Date.parse("July 6, 2016")
-      answer = [Date.parse("June 8, 2016")]
+    context "Parse International Standard fully numeric date" do
+      text = "24-07-2015"
+      answer = [Date.parse("24-07-2015")]
       
       it "correctly grabs the date" do
-        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+        expect(DateParser::parse(text)).to eql(answer)
       end
     end
-    
   end
-end
-
-
-describe DateParser do
   
   #########################################################
   ##
-  ## More Edge Cases looking at specific features.
+  ## Type Testing
   ##
   
+  #########################
+  ## Negative Tests
+  ##
   describe ".parse" do
-    context "Parse fully numeric date" do
+    context "Passing an int for creation_date" do
       text = "2012-02-12"
-      answer = [Date.parse("2012-02-12")]
+      creation_date = 12
       
-      it "correctly grabs the date" do
-        expect(DateParser::parse(text)).to eql(answer)
+      it "Raises an exception" do
+        expect { DateParser::parse(text, creation_date) }.to raise_exception(ArgumentError)
       end
     end
     
-    context "Parse American fully numeric date" do
-      text = "7-24-2015"
-      answer = [Date.parse("July 24, 2015")]
+    context "Passing a String for creation_date" do
+      text = "2012-02-12"
+      creation_date = "Test"
       
-      it "correctly grabs the date" do
-        expect(DateParser::parse(text)).to eql(answer)
+      it "Raises an exception" do
+        expect { DateParser::parse(text, creation_date) }.to raise_exception(ArgumentError)
       end
     end
     
-    context "Parse International Standard fully numeric date" do
-      text = "24-07-2015"
-      answer = [Date.parse("24-07-2015")]
+    context "Passing a Time for creation_date" do
+      text = "2012-02-12"
+      creation_date = Time.at(0)
       
-      it "correctly grabs the date" do
-        expect(DateParser::parse(text)).to eql(answer)
+      it "Raises an exception" do
+        expect { DateParser::parse(text, creation_date) }.to raise_exception(ArgumentError)
+      end
+    end
+    
+    #########################
+    ## Positive Tests
+    ##
+    context "Passing in a DateTime object for creation_date" do
+      text = "Something something something march 4 something something"
+      creation_date = DateTime.parse("Jan 1, 2004")
+      answer = [Date.parse("March 4, 2004")]
+      
+      it "Does not raise an exception, and produces the correct answer" do
+        expect(DateParser::parse(text, creation_date)).to eql(answer)
       end
     end
   end

data/lib/spec/natural_date_parsing_spec.rb

@@ -0,0 +1,260 @@
+require_relative "../date_parser"
+
+describe NaturalDateParsing do
+  
+  #########################################################
+  ##
+  ## Basic Mechanics Testing
+  ##
+  
+  before do
+    
+    @date = "April 6th, 2014"
+    @text = "Remember to meet me on April 6th, 2014, alright?"
+    @paragraph = "April 6th, 2014 isn't good for me. We should meet instead on\n" +
+                 "February 4th, 2013. Or even March 31st, 2017. No rush."
+    
+    @parsed_date = [Date.parse("April 6th, 2014")]
+    @parsed_date_paragraph = [
+                              Date.parse("April 6th, 2014"),
+                              Date.parse("February 4th, 2013"),
+                              Date.parse("March 31st, 2017")
+                              ]
+  end
+  
+  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)
+      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)
+      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)
+      end
+    end
+  end
+end
+
+
+describe NaturalDateParsing do
+  
+  #########################################################
+  ##
+  ## Edge Cases. More Colloquial Language. More complicated phrases.
+  ##
+  
+  describe ".interpret_date" do
+    
+    context "Given a longer sentence containing a date" do
+      text = "La Puerta del Conde (The Count's Gate) is the site in Santo" + 
+        "Domingo, Dominican Republic where Francisco del Rosario Sánchez, one of the" + 
+        "Dominican Founding Fathers, proclaimed Dominican independence and raised the" + 
+        "first Dominican Flag, on February 27, 1844."
+      creation_date = nil
+      answer = [Date.parse("February 27, 1844")]
+      
+      it "captures the single date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Colloquial use of date 1" do
+      text = "We should go on the 4th if we can."
+      creation_date = Date.parse("July 1st 2016")
+      answer = [Date.parse("July 4th, 2016")]
+      
+      it "correctly uses the creation_date parameter" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Correct use of XX/XX format 1" do
+      text = "Newsflash: things happen on 02/12!"
+      creation_date = Date.parse("January 1st, 1994")
+      answer = [Date.parse("February 12, 1994")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Given yesterday" do
+      text = "Yesterday was certainly a day."
+      creation_date = nil
+      answer = [Date.today - 1]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Given yesterday with a creation_date date" do
+      text = "Yesterday was certainly a day."
+      creation_date = Date.parse("January 12, 1994")
+      answer = [Date.parse("January 11, 1994")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Single year is correctly parsed" do
+      text = "In 1492 Columbus sailed the ocean blue."
+      creation_date = nil
+      answer = [Date.parse("January 1, 1492")]
+      parse_single_years = true
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date, parse_single_years)).to eql(answer)
+      end
+    end
+    
+    context "Correctly parses month and day in middle of sentence" do
+      text = "Something something something march 4 something something"
+      creation_date = Date.parse("Jan 1, 2004")
+      answer = [Date.parse("March 4, 2004")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+  end
+end
+
+
+describe NaturalDateParsing do
+  
+  #########################################################
+  ##
+  ## Colloquial Language samples from volunteers
+  ##
+  
+  describe ".interpret_date" do
+    
+    context "Colloquial example 1" do
+      text = "Charlie Chaplin and Jason Earles (Hannah Montana's brother) were " +
+      "alive at the same time for eight months in 1977"
+      creation_date = Date.parse("July 6, 2016")
+      answer = [Date.parse("January 1, 1977")]
+      parse_single_years = true
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date, parse_single_years)).to eql(answer)
+      end
+    end
+    
+    ## Stopping this test for right now. Hard to tell which April.
+    ## Ambiguous in the general case.
+    #context "Colloquial example 2" do
+    #  text = "For a job I started this April, I had to parse dates of various " +
+    #  "formats, such as MM-DD-YY, MM/YYYY, and YY-MM-DD. It was infuriating, " +
+    #  "and what I assume you to be doing reminds me of this."
+    #  creation_date = Date.parse("July 6, 2016")
+    #  answer = [Date.parse("April 1, 2016")] ## Reconsider
+    #  
+    #  it "correctly grabs the date" do
+    #    expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+    #  end
+    #end
+    
+    context "Colloquial example 3" do
+      text = "August 25, 2013, I met So-and-So"
+      creation_date = Date.parse("July 6, 2016")
+      answer = [Date.parse("August 25, 2013")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Colloquial example 4" do
+      text = "Quincy Jones (producer of Thriller) and Michael Caine (veteran " +
+      "British actor) were both born on the same day and the same hour on March " +
+      "14, 1933. They are still friends to this day."
+      creation_date = Date.parse("July 6, 2016")
+      answer = [Date.parse("March 14, 1933")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Colloquial example 5" do
+      text = "Two days ago (July 4, 2016) was the 190th death anniversary of " +
+      "the second and third US Presidents: John Adams and Thomas Jefferson, who died 5 hours apart."
+      creation_date = Date.parse("July 6, 2016")
+      answer = [Date.parse("July 4, 2016")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Colloquial example 6" do
+      text = "On October 3rd So-and-So asked me what day it was"
+      creation_date = Date.parse("July 6, 2016")
+      answer = [Date.parse("October 3, 2016")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Colloquial example 7" do
+      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")
+      answer = [Date.parse("January 1, 2018"),
+                Date.parse("July 11, 2016")] # Reconsider
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Colloquial example 8" do
+      text = "Beyoncé Giselle Knowles-Carter was born on September 4, 1981."
+      creation_date = Date.parse("July 6, 2016")
+      answer = [Date.parse("September 4, 1981")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Colloquial example 9" do
+      text = "The first time I asked someone on a date, I was in Iowa, it was a " +
+      "winterly mid-month January, we were to go to finding nemo, I was 9, and " +
+      "although she was interested, her parents said no."
+      creation_date = Date.parse("July 6, 2016")
+      answer = [Date.parse("January 1st, 2016")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+    context "Colloquial example 10" do
+      text = "You ate 10 dates from a crate of dates that were picked on June " +
+      "8th from a date tree that was cultivated one score and three years ago. " +
+      "Good luck parsing through the antics of my semantics."
+      creation_date = Date.parse("July 6, 2016")
+      answer = [Date.parse("June 8, 2016")]
+      
+      it "correctly grabs the date" do
+        expect(NaturalDateParsing::interpret_date(text, creation_date)).to eql(answer)
+      end
+    end
+    
+  end
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: date_parser
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Ryan Kwon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-26 00:00:00.000000000 Z
+date: 2016-09-15 00:00:00.000000000 Z
 dependencies: []
 description: DateParser is a simple, fast, and effective way to parse dates from natural
-  language text in a robust way.
+  language text.
 email: rynkwn@gmail.com
 executables: []
 extensions: []
@@ -26,6 +26,7 @@ files:
 - lib/date_parser/natural_date_parsing.rb
 - lib/date_parser/utils.rb
 - lib/spec/date_parser_spec.rb
+- lib/spec/natural_date_parsing_spec.rb
 homepage: https://github.com/rynkwn/DateParser
 licenses:
 - MIT
@@ -49,6 +50,7 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Quickly parse natural language into dates robustly.
+summary: Robust natural language parsing for dates.
 test_files:
 - lib/spec/date_parser_spec.rb
+- lib/spec/natural_date_parsing_spec.rb