Switch artichoke-backend to use spinoso-time tzrs feature

[b-n]

#1927 Added enough to hopefully make tzrs feature safe for replacement of the chrono feature in arthicoke-backend. This PR achieves to do exactly that

Compatibility

The previous version of Time#at supported only the syntax that mruby did. This PR introduces all options available as at MRI 3.1.2.

Time#succ now uses the same logic as Time#+ which wasn't implemented before.

Time#+ is now implemented, and follows MRI

Time#- changes:

• The previous version use to just return rhs when subtracting one time from another (this now returns a float as per MRI)
• Arthimetic with intergers/floats now works

[lopopolo]

Hi @b-n I've seen this but haven't had time to sit down and give a proper review yet. I took a glance and things look like they came together nicely. I hope to get to this sometime this week.

[lopopolo]

Heads up, despite the crate being named artichoke-backend this change should be tagged B-mruby.

The B- tags refer to the VM implementation. B-Artichoke is a hypothetical pure Rust VM that we'll write in house.

[b-n]

@lopopolo I'll pick this one up again shortly, sorry for taking a while to get back around to it!

[b-n]

@lopopolo Converting this one back to draft since there's still some reasonably sized changes that I need to check. 3dd1b6b might be pique your interest 😅

[b-n]

Also, do you have a preference on tabled vs. non tabled tests? (below are the same tests)

Table tests:

    #[test]
    fn subsec_millis_tabled() {
        let mut interp = interpreter();

        let table: HashMap<&[u8], (i64, u32)> = HashMap::from([
            (b"-1001".as_slice(), (-2, 999_000_000)),
            (b"-1000".as_slice(), (-2, 0)),
            (b"-999".as_slice(), (-1, 1_000_000)),
            (b"-1".as_slice(), (-1, 999_000_000)),
            (b"0".as_slice(), (0, 0)),
            (b"999".as_slice(), (0, 999_000_000)),
            (b"1000".as_slice(), (1, 0)),
            (b"1001".as_slice(), (1, 1_000_000))
        ]);

        let unit = b":milliseconds";

        for (input, expectation) in table {
            let result = subsec(&mut interp, (Some(input), Some(unit))).unwrap();
            assert_eq!(
                result.to_tuple(),
                expectation,
                "Expected TryConvertMut<(Some({}), Some({})), Result<Subsec>>, to return {} secs, {} nanos",
                input.as_bstr(),
                unit.as_bstr(),
                expectation.0,
                expectation.1
            );
        }
    }

Not so tabled:

    #[test]
    fn subsec_millis() {
        let mut interp = interpreter();

        let result = subsec(&mut interp, (Some(b"-1001"), Some(b":milliseconds"))).unwrap();
        assert_eq!(result.to_tuple(), (-2, -999_000_000));

        let result = subsec(&mut interp, (Some(b"-1000"), Some(b":milliseconds"))).unwrap();
        assert_eq!(result.to_tuple(), (-2, 0));

        let result = subsec(&mut interp, (Some(b"-999"), Some(b":milliseconds"))).unwrap();
        assert_eq!(result.to_tuple(), (-1, 1_000_000));

        let result = subsec(&mut interp, (Some(b"-1"), Some(b":milliseconds"))).unwrap();
        assert_eq!(result.to_tuple(), (-1, 999_000_000));

        let result = subsec(&mut interp, (Some(b"0"), Some(b":milliseconds"))).unwrap();
        assert_eq!(result.to_tuple(), (0, 0));

        let result = subsec(&mut interp, (Some(b"999"), Some(b":milliseconds"))).unwrap();
        assert_eq!(result.to_tuple(), (0, 999_000_000));

        let result = subsec(&mut interp, (Some(b"1000"), Some(b":milliseconds"))).unwrap();
        assert_eq!(result.to_tuple(), (1, 0));

        let result = subsec(&mut interp, (Some(b"1001"), Some(b":milliseconds"))).unwrap();
        assert_eq!(result.to_tuple(), (1, 1_000_000));
    }

[lopopolo]

Also, do you have a preference on tabled vs. non tabled tests? (below are the same tests)

I've been leaning toward table driven tests lately, especially for things like parsers, and have been liking how clean things look. I haven't been using HashMaps for this though, instead preferring an array of tuples, like:

artichoke/scolapasta-int-parse/src/error.rs

Lines 348 to 362 in 995b8ca

	#[test]
	fn argument_error_display_from_invalid_subject() {
	let test_cases: &[(&[u8], &str)] = &[
	(b"\xFF", r#"invalid value for Integer(): "\xFF""#),
	("🦀".as_bytes(), r#"invalid value for Integer(): "🦀""#),
	// XXX: for UTF-8 strings, "\x00".inspect is "\u0000".
	(b"\x00", r#"invalid value for Integer(): "\x00""#),
	];
	for (input, message) in test_cases.iter().copied() {
	let err = ArgumentError::from(input);
	let mut buf = String::new();
	write!(&mut buf, "{}", err).unwrap();
	assert_eq!(&*buf, message, "unexpected value for test case '{input:?}'");
	}
	}

[lopopolo]

All comments resolved and fixups filed as tickets.

Will merge this when the build is green.