From 056b45aeed1672b54756a304bbf3e3ea65138f2d Mon Sep 17 00:00:00 2001 From: "T. Nagasawa" Date: Sun, 8 Jul 2018 02:09:46 +0900 Subject: [PATCH] bindings for Date.parse and Date.getXXX (#414) * binding for Date.prototype.getHours() * binding for Date.prototype.getMilliseconds() * binding for Date.prototype.getMinutes() * binding for Date.prototype.getMonth() * binding for Date.prototype.getSeconds() * binding for Date.prototype.getTime() * binding for Date.parse() --- src/js.rs | 46 +++++++ tests/all/js_globals/Date.rs | 242 +++++++++++++++++++++++++++++++++++ 2 files changed, 288 insertions(+) diff --git a/src/js.rs b/src/js.rs index 4733e92c..76d0ea3c 100644 --- a/src/js.rs +++ b/src/js.rs @@ -828,6 +828,44 @@ extern "C" { #[wasm_bindgen(method, js_name = getFullYear)] pub fn get_full_year(this: &Date) -> u32; + /// The getHours() method returns the hour for the specified date, according to local time. + /// + /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getHours + #[wasm_bindgen(method, js_name = getHours)] + pub fn get_hours(this: &Date) -> u32; + + /// The getMilliseconds() method returns the milliseconds in the specified date according to local time. + /// + /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds + #[wasm_bindgen(method, js_name = getMilliseconds)] + pub fn get_milliseconds(this: &Date) -> u32; + + /// The getMinutes() method returns the minutes in the specified date according to local time. + /// + /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMinutes + #[wasm_bindgen(method, js_name = getMinutes)] + pub fn get_minutes(this: &Date) -> u32; + + /// The getMonth() method returns the month in the specified date according to local time, + /// as a zero-based value (where zero indicates the first month of the year). + /// + /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getMonth + #[wasm_bindgen(method, js_name = getMonth)] + pub fn get_month(this: &Date) -> u32; + + /// The getSeconds() method returns the seconds in the specified date according to local time. + /// + /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getSeconds + #[wasm_bindgen(method, js_name = getSeconds)] + pub fn get_seconds(this: &Date) -> u32; + + /// The getTime() method returns the numeric value corresponding to the time for the specified date + /// according to universal time. + /// + /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTime + #[wasm_bindgen(method, js_name = getTime)] + pub fn get_time(this: &Date) -> f64; + /// Creates a JavaScript Date instance that represents /// a single moment in time. Date objects are based on a time value that is /// the number of milliseconds since 1 January 1970 UTC. @@ -843,6 +881,14 @@ extern "C" { #[wasm_bindgen(static_method_of = Date)] pub fn now() -> f64; + /// The Date.parse() method parses a string representation of a date, and returns the number of milliseconds + /// since January 1, 1970, 00:00:00 UTC or NaN if the string is unrecognized or, in some cases, + /// contains illegal date values (e.g. 2015-02-31). + /// + /// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse + #[wasm_bindgen(static_method_of = Date)] + pub fn parse(date: JsString) -> f64; + /// The toDateString() method returns the date portion of a Date object /// in human readable form in American English. /// diff --git a/tests/all/js_globals/Date.rs b/tests/all/js_globals/Date.rs index 9c7dab9a..b649f409 100755 --- a/tests/all/js_globals/Date.rs +++ b/tests/all/js_globals/Date.rs @@ -106,6 +106,212 @@ fn get_full_year() { .test() } +#[test] +fn get_hours() { + project() + .file( + "src/lib.rs", + r#" + #![feature(proc_macro, wasm_custom_section)] + + extern crate wasm_bindgen; + use wasm_bindgen::prelude::*; + use wasm_bindgen::js::Date; + + #[wasm_bindgen] + pub fn get_hours(this: &Date) -> u32 { + this.get_hours() + } + "#, + ) + .file( + "test.js", + r#" + import * as assert from "assert"; + import * as wasm from "./out"; + + export function test() { + let date = new Date('March 13, 08 04:20'); + + assert.equal(wasm.get_hours(date), 4); + } + "#, + ) + .test() +} + +#[test] +fn get_milliseconds() { + project() + .file( + "src/lib.rs", + r#" + #![feature(proc_macro, wasm_custom_section)] + + extern crate wasm_bindgen; + use wasm_bindgen::prelude::*; + use wasm_bindgen::js::Date; + + #[wasm_bindgen] + pub fn get_milliseconds(this: &Date) -> u32 { + this.get_milliseconds() + } + "#, + ) + .file( + "test.js", + r#" + import * as assert from "assert"; + import * as wasm from "./out"; + + export function test() { + let date = new Date('July 20, 69 00:20:18'); + let dateWithMs = new Date('July 20, 69 00:20:18:123'); + + assert.equal(wasm.get_milliseconds(date), 0); + assert.equal(wasm.get_milliseconds(dateWithMs), 123); + } + "#, + ) + .test() +} + +#[test] +fn get_minutes() { + project() + .file( + "src/lib.rs", + r#" + #![feature(proc_macro, wasm_custom_section)] + + extern crate wasm_bindgen; + use wasm_bindgen::prelude::*; + use wasm_bindgen::js::Date; + + #[wasm_bindgen] + pub fn get_minutes(this: &Date) -> u32 { + this.get_minutes() + } + "#, + ) + .file( + "test.js", + r#" + import * as assert from "assert"; + import * as wasm from "./out"; + + export function test() { + let date = new Date('March 13, 08 04:20'); + + assert.equal(wasm.get_minutes(date), 20); + } + "#, + ) + .test() +} + +#[test] +fn get_month() { + project() + .file( + "src/lib.rs", + r#" + #![feature(proc_macro, wasm_custom_section)] + + extern crate wasm_bindgen; + use wasm_bindgen::prelude::*; + use wasm_bindgen::js::Date; + + #[wasm_bindgen] + pub fn get_month(this: &Date) -> u32 { + this.get_month() + } + "#, + ) + .file( + "test.js", + r#" + import * as assert from "assert"; + import * as wasm from "./out"; + + export function test() { + let date = new Date('July 20, 69 00:20:18'); + + assert.equal(wasm.get_month(date), 6); + } + "#, + ) + .test() +} + +#[test] +fn get_seconds() { + project() + .file( + "src/lib.rs", + r#" + #![feature(proc_macro, wasm_custom_section)] + + extern crate wasm_bindgen; + use wasm_bindgen::prelude::*; + use wasm_bindgen::js::Date; + + #[wasm_bindgen] + pub fn get_seconds(this: &Date) -> u32 { + this.get_seconds() + } + "#, + ) + .file( + "test.js", + r#" + import * as assert from "assert"; + import * as wasm from "./out"; + + export function test() { + let date = new Date('July 20, 69 00:20:18'); + + assert.equal(wasm.get_seconds(date), 18); + } + "#, + ) + .test() +} + +#[test] +fn get_time() { + project() + .file( + "src/lib.rs", + r#" + #![feature(proc_macro, wasm_custom_section)] + + extern crate wasm_bindgen; + use wasm_bindgen::prelude::*; + use wasm_bindgen::js::Date; + + #[wasm_bindgen] + pub fn get_time(this: &Date) -> f64 { + this.get_time() + } + "#, + ) + .file( + "test.js", + r#" + import * as assert from "assert"; + import * as wasm from "./out"; + + export function test() { + let date = new Date('July 20, 69 00:20:18 GMT+00:00'); + + assert.equal(wasm.get_time(date), -14254782000); + } + "#, + ) + .test() +} + #[test] fn new() { project() @@ -164,6 +370,42 @@ fn now() { .test() } +#[test] +fn parse() { + project() + .file( + "src/lib.rs", + r#" + #![feature(proc_macro, wasm_custom_section)] + + extern crate wasm_bindgen; + use wasm_bindgen::prelude::*; + use wasm_bindgen::js::{Date, JsString}; + + #[wasm_bindgen] + pub fn parse(date: JsString) -> f64 { + Date::parse(date) + } + "#, + ) + .file( + "test.js", + r#" + import * as assert from "assert"; + import * as wasm from "./out"; + + export function test() { + let date = wasm.parse('04 Dec 1995 00:12:00 GMT'); + let unixTimeZero = wasm.parse('01 Jan 1970 00:00:00 GMT'); + + assert.equal(date, 818035920000); + assert.equal(unixTimeZero, 0); + } + "#, + ) + .test() +} + #[test] fn to_date_string() { project()