chrono-node 1.3.5 → 1.4.4

package/test/pt/pt_slash.test.js

@@ -0,0 +1,44 @@
+var chrono = require('../../src/chrono');
+
+test("Test - Single Expression", function() {
+
+    var text = "segunda 8/2/2016";
+    var results = chrono.parse(text, new Date(2012,7,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('year')).toBe(2016)
+        expect(result.start.get('month')).toBe(2)
+        expect(result.start.get('day')).toBe(8)
+
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('segunda 8/2/2016')
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2016, 2-1, 8, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+    var text = "Terça-feira 9/2/2016";
+    var results = chrono.parse(text, new Date(2012,7,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('year')).toBe(2016)
+        expect(result.start.get('month')).toBe(2)
+        expect(result.start.get('day')).toBe(9)
+
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('Terça-feira 9/2/2016')
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2016, 2-1, 9, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+
+});

package/test/pt/pt_time_ago.test.js

@@ -0,0 +1,137 @@
+var chrono = require('../../src/chrono');
+
+test("Test - Single Expression", function() {
+
+    var text = "há 5 dias, fizemos algo";
+    var results = chrono.parse(text, new Date(2012,7,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('year')).toBe(2012)
+        expect(result.start.get('month')).toBe(8)
+        expect(result.start.get('day')).toBe(5)
+
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('há 5 dias')
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012, 8-1, 5, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+    var text = "há 10 dias, fizemos algo";
+    var results = chrono.parse(text, new Date(2012,7,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('year')).toBe(2012)
+        expect(result.start.get('month')).toBe(7)
+        expect(result.start.get('day')).toBe(31)
+
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('há 10 dias')
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012, 7-1, 31, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+
+    var text = "há 15 minutos";
+    var results = chrono.parse(text, new Date(2012,7,10,12,14));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('há 15 minutos')
+        expect(result.start.get('hour')).toBe(11)
+        expect(result.start.get('minute')).toBe(59)
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012,7,10,11,59);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+    var text = "   há 12 horas";
+    var results = chrono.parse(text, new Date(2012,7,10,12,14));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.index).toBe(3)
+        expect(result.text).toBe('há 12 horas')
+        expect(result.start.get('hour')).toBe(0)
+        expect(result.start.get('minute')).toBe(14)
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012,7,10,0,14);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+});
+
+
+test("Test - Single Expression (Casual)", function() {
+
+    var text = "há 5 meses, fizemos algo";
+    var results = chrono.parse(text, new Date(2012, 8-1,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('year')).toBe(2012)
+        expect(result.start.get('month')).toBe(3)
+        expect(result.start.get('day')).toBe(10)
+
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('há 5 meses')
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012, 3-1, 10, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+    var text = "há 5 anos, fizemos algo";
+    var results = chrono.parse(text, new Date(2012, 8-1,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('year')).toBe(2007)
+        expect(result.start.get('month')).toBe(8)
+        expect(result.start.get('day')).toBe(10)
+
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('há 5 anos')
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2007, 8-1, 10, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+
+    var text = "há uma semana, fizemos algo";
+    var results = chrono.parse(text, new Date(2012, 8-1, 3));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('year')).toBe(2012)
+        expect(result.start.get('month')).toBe(7)
+        expect(result.start.get('day')).toBe(27)
+
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('há uma semana')
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012, 7-1, 27, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+});

package/test/pt/pt_time_exp.test.js

@@ -0,0 +1,240 @@
+var chrono = require('../../src/chrono');
+
+test("Test - Single Expression", function() {
+
+
+    var text = "Ficaremos às 6.13 AM";
+    var results = chrono.parse(text, new Date(2012,7,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.index).toBe(10)
+        expect(result.text).toBe('às 6.13 AM')
+
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('hour')).toBe(6)
+        expect(result.start.get('minute')).toBe(13)
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012, 7, 10, 6, 13);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+
+
+});
+
+test("Test - Range Expression", function() {
+
+    var text = "8:10 - 12.32";
+    var results = chrono.parse(text, new Date(2012,7,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('8:10 - 12.32')
+
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('hour')).toBe(8)
+        expect(result.start.get('minute')).toBe(10)
+
+        expect(result.start.isCertain('day')).toBe(false)
+        expect(result.start.isCertain('month')).toBe(false)
+        expect(result.start.isCertain('year')).toBe(false)
+        expect(result.start.isCertain('hour')).toBe(true)
+        expect(result.start.isCertain('minute')).toBe(true)
+        expect(result.start.isCertain('second')).toBe(false)
+        expect(result.start.isCertain('millisecond')).toBe(false)
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012, 7, 10, 8, 10);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+
+        expect(result.end).not.toBeNull()
+        expect(result.end.get('hour')).toBe(12)
+        expect(result.end.get('minute')).toBe(32)
+
+        expect(result.end.isCertain('day')).toBe(false)
+        expect(result.end.isCertain('month')).toBe(false)
+        expect(result.end.isCertain('year')).toBe(false)
+        expect(result.end.isCertain('hour')).toBe(true)
+        expect(result.end.isCertain('minute')).toBe(true)
+        expect(result.end.isCertain('second')).toBe(false)
+        expect(result.end.isCertain('millisecond')).toBe(false)
+
+        var resultDate = result.end.date();
+        var expectDate = new Date(2012, 7, 10, 12, 32);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+    var text = " de 6:30pm a 11:00pm ";
+    var results = chrono.parse(text, new Date(2012,7,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.index).toBe(1)
+        expect(result.text).toBe('de 6:30pm a 11:00pm')
+
+        expect(result.start).not.toBeNull()
+        expect(result.start.get('hour')).toBe(18)
+        expect(result.start.get('minute')).toBe(30)
+        expect(result.start.get('meridiem')).toBe(1)
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012, 7, 10, 18, 30);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+
+        expect(result.end).not.toBeNull()
+        expect(result.end.get('hour')).toBe(23)
+        expect(result.end.get('minute')).toBe(0)
+        expect(result.end.get('meridiem')).toBe(1)
+
+        var resultDate = result.end.date();
+        var expectDate = new Date(2012, 7, 10, 23, 0);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+});
+
+test("Test - Date + Time Expression", function() {
+
+    var text = "Algo passou em 10 de Agosto de 2012 10:12:59 pm";
+    var results = chrono.parse(text, new Date(2012,7,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if(result){
+        expect(result.index).toBe(15)
+        expect(result.text).toBe('10 de Agosto de 2012 10:12:59 pm')
+
+        expect(result.start.get('year')).toBe(2012)
+        expect(result.start.get('month')).toBe(8)
+        expect(result.start.get('day')).toBe(10)
+        expect(result.start.get('hour')).toBe(22)
+        expect(result.start.get('minute')).toBe(12)
+        expect(result.start.get('second')).toBe(59)
+        expect(result.start.get('millisecond')).toBe(0)
+        expect(result.start.isCertain('millisecond')).toBe(false)
+
+        var resultDate = result.start.date();
+        var expectDate = new Date(2012, 8-1, 10, 22, 12, 59);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime())
+    }
+
+})
+
+
+test("Test - Time Expression's Meridiem imply", function() {
+
+    var text = "hoje de 1pm a 3";
+    var results = chrono.parse(text, new Date(2012,7,10));
+    expect(results.length).toBe(1)
+
+    var result = results[0];
+    if (result) {
+        expect(result.index).toBe(0)
+        expect(result.text).toBe('hoje de 1pm a 3')
+
+        expect(result.start.get('year')).toBe(2012)
+        expect(result.start.get('month')).toBe(8)
+        expect(result.start.get('day')).toBe(10)
+        expect(result.start.get('hour')).toBe(13)
+        expect(result.start.get('minute')).toBe(0)
+        expect(result.start.get('second')).toBe(0)
+        expect(result.start.get('millisecond')).toBe(0)
+        expect(result.start.get('meridiem')).toBe(1)
+        expect(result.start.isCertain('meridiem')).toBe(true)
+
+        expect(result.end.get('year')).toBe(2012)
+        expect(result.end.get('month')).toBe(8)
+        expect(result.end.get('day')).toBe(11)
+        expect(result.end.get('hour')).toBe(3)
+        expect(result.end.get('minute')).toBe(0)
+        expect(result.end.get('second')).toBe(0)
+        expect(result.end.get('millisecond')).toBe(0)
+        expect(result.end.isCertain('meridiem')).toBe(false)
+    }
+})
+
+
+test("Test - Random date + time expression", function() {
+
+    var text = "segunda 4/29/2013 630-930am";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "terça 5/1/2013 1115am";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "quarta 5/3/2013 1230pm";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+
+    var text = "domingo 5/6/2013  750am-910am";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "segunda-feira 5/13/2013 630-930am";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "quarta-feira 5/15/2013 1030am";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "quinta 6/21/2013 2:30";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "terça-feira 7/2/2013 1-230 pm";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "Segunda-feira, 6/24/2013, 7:00pm - 8:30pm";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "Quinta6/20/2013 from 7:00 PM to 10:00 PM";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "Quarta, 3 Julho de 2013 às 2pm";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+
+    var text = "6pm";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "6 pm";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "7-10pm";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "11.1pm";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "às 12";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+
+    var text = "ao meio-dia";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+    expect(result.start.get('hour')).toBe(12)
+    expect(result.start.get('hour')).toBe(12)
+
+    var text = "a meia-noite";
+    var result = chrono.parse(text)[0];
+    expect(result.text).toBe(text)
+})

package/test/system.test.js

@@ -0,0 +1,207 @@
+const chrono = require('../src/chrono');
+
+var ok = function() {
+	expect(arguments[0]).toBeTruthy();
+}
+
+//-------------------------------------
+
+test("Test - Load modules", function() {
+
+	expect(chrono).toBeDefined();
+
+	expect(chrono.Chrono).toBeDefined();
+
+	expect(chrono.Chrono).toBeDefined();
+
+	expect(chrono.Parser).toBeDefined();
+
+	expect(chrono.Refiner).toBeDefined();
+
+	expect(chrono.ParsedResult).toBeDefined();
+
+	expect(chrono.ParsedComponents).toBeDefined();
+
+	expect(chrono.parse).toBeDefined();
+
+	expect(chrono.parseDate).toBeDefined();
+
+	expect(chrono.options).toBeDefined();
+
+	expect(chrono.casual).toBeDefined();
+
+	expect(chrono.strict).toBeDefined();
+});
+
+
+test("Test - Create & manipulate date results", function() {
+
+	var components = new chrono.ParsedComponents( {year: 2014, month: 11, day: 24});
+	expect(components.get('year')).toBe(2014);
+	expect(components.get('month')).toBe(11);
+	expect(components.get('day')).toBe(24);
+	expect(components.date()).toBeDefined();
+
+	// undefined
+	expect(components.get('dayOfWeek')).toBeUndefined(undefined);
+	expect(components.isCertain('dayOfWeek')).toBe(false);
+
+	// "imply"
+	components.imply('dayOfWeek', 1);
+	expect(components.get('dayOfWeek')).toBe(1);
+	expect(components.isCertain('dayOfWeek')).toBe(false);
+	
+	// "assign" overrides "imply"
+	components.assign('dayOfWeek', 2);
+	expect(components.get('dayOfWeek')).toBe(2);
+	expect(components.isCertain('dayOfWeek')).toBe(true);
+
+	// "imply" doesn't overrides "assign"
+	components.imply('year', 2013);
+	expect(components.get('year')).toBe(2014);
+
+	// "assign" overrides "assign"
+	components.assign('year', 2013)
+	expect(components.get('year')).toBe(2013);
+});
+
+test("Test - Calendar Checking", function() {
+
+	var components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24});
+	expect(components.isPossibleDate()).toBe(true);
+
+	var components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12});
+	expect(components.isPossibleDate()).toBe(true);
+
+	var components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12, minute: 30});
+	expect(components.isPossibleDate()).toBe(true);
+
+	var components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12, minute: 30, second: 30});
+	expect(components.isPossibleDate()).toBe(true);
+
+	var components = new chrono.ParsedComponents({year: 2014, month: 13, day: 24});
+	expect(components.isPossibleDate()).toBe(false);
+
+	var components = new chrono.ParsedComponents({year: 2014, month: 11, day: 32});
+	expect(components.isPossibleDate()).toBe(false);
+
+	var components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:24});
+	expect(components.isPossibleDate()).toBe(false);
+
+	var components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12, minute: 60});
+	expect(components.isPossibleDate()).toBe(false);
+
+	var components = new chrono.ParsedComponents({year: 2014, month: 11, day: 24, hour:12, minute: 30, second: 60});
+	expect(components.isPossibleDate()).toBe(false);
+});
+
+test("Test - Override parser", function() {
+
+	var originalText = '01234-pattern-01234-pattern';
+	var originalOpt = { some: 'thing'};
+	var extractCalled = 0;
+
+	function CustomParser() {
+		chrono.Parser.apply(this, arguments);
+
+		this.pattern = function () { return /pattern/; }
+		this.extract = function(text, ref, match, opt){
+
+			if(extractCalled == 0){
+				expect(text).toBe(originalText);
+				expect(opt).toBe(originalOpt);
+				expect(match.index).toBe(6);
+			} else if(extractCalled == 1){
+				expect(text).toBe(originalText);
+				expect(opt).toBe(originalOpt);
+				expect(match.index).toBe(20);
+			}
+
+			extractCalled += 1;
+			return null;
+		}
+	}
+
+	var customParser = new CustomParser();
+	var results = customParser.execute(originalText, new Date(), originalOpt);
+	expect(extractCalled).toBe(2);
+});
+
+test("Test - Add custom parser", function() {
+    var customParser = new chrono.Parser();
+
+    customParser.pattern = function () { return /(\d{1,2})(st|nd|rd|th)/i } 
+    customParser.extract = function(text, ref, match, opt) { 
+        return new chrono.ParsedResult({
+            ref: ref,
+            text: match[0],
+            index: match.index,
+            start: {
+                day: parseInt(match[1]) 
+            }
+        });
+	}
+	
+    var custom = new chrono.Chrono();
+    custom.parsers.push(customParser);
+
+    var text = "meeting on 25th";
+	var result = custom.parse(text, new Date(2017,11 -1, 19))[0];
+	
+    expect(result.text).toBe('25th')
+    expect(result.start.get('month')).toBe(11)
+    expect(result.start.get('day')).toBe(25)
+})
+
+test("Test - combining options", function() {
+
+	var firstOption = {
+		parsers: [
+			new chrono.parser.ENISOFormatParser(),
+		],
+		refiners: [
+			new chrono.refiner.OverlapRemovalRefiner(),
+		]
+	}
+
+	var secondOption = {
+		parsers: [
+			new chrono.parser.ENISOFormatParser(),
+			new chrono.parser.JPStandardParser(),
+		],
+		refiners: []
+	}
+
+	var mergedOption = chrono.options.mergeOptions([
+		firstOption,
+		secondOption
+	]);
+
+	ok(mergedOption);
+	expect(mergedOption.parsers.length).toBe(2);
+	expect(mergedOption.refiners.length).toBe(1);
+
+	var customChrono = new chrono.Chrono(mergedOption);
+	expect(customChrono.parseDate('2012-9-3')).not.toBeNull();
+	expect(customChrono.parseDate('2012年９月3日')).not.toBeNull();
+	expect(customChrono.parseDate('Tuesday')).toBeNull();
+});
+
+test("Test - default language options", function() {
+
+	expect(chrono.ja.parseDate('2012-9-3')).not.toBeNull();
+	expect(chrono.ja.parseDate('2012年９月3日')).not.toBeNull();
+	expect(chrono.ja.parseDate('Lundi')).toBeNull();
+
+	expect(chrono.fr.parseDate('2012-9-3')).not.toBeNull();
+	expect(chrono.fr.parseDate('Lundi')).not.toBeNull();
+	expect(chrono.fr.parseDate('2012年９月3日')).toBeNull();
+
+	expect(chrono.en.parseDate("04/12/1993"))
+		.toEqual(chrono.parseDate("1993-04-12"))
+	
+	expect(chrono.en_GB.parseDate("04/12/1993"))
+		.toEqual(chrono.parseDate("1993-12-04"))
+});
+
+