feat!: multiple of datetime creation methods was replaced by Astra.datetime.new

Author: ElhamAryanpur

src/components/datetime.lua

@@ -1,10 +1,6 @@
 ---@meta
 
 ---@class DateTime
----@field new_now fun(): DateTime
----@field new_from fun(year: number, month: number?, day: number?, hour: number?, min: number?, sec: number?, milli: number?): DateTime
----@field new_utc_now fun(): DateTime
----@field new_utc_from fun(year: number, month: number?, day: number?, hour: number?, min: number?, sec: number?, milli: number?): DateTime
 ---@field get_year fun(datetime: DateTime): number
 ---@field get_month fun(datetime: DateTime): number
 ---@field get_day fun(datetime: DateTime): number
@@ -15,6 +11,8 @@
 ---@field get_millisecond fun(datetime: DateTime): number
 ---@field get_epoch_milliseconds fun(datetime: DateTime): number
 ---@field get_timezone_offset fun(datetime: DateTime): number
+---@field to_rfc2822 fun(datetime: DateTime): string
+---@field to_rfc3339 fun(datetime: DateTime): string
 ---@field set_year fun(datetime:DateTime, year: number)
 ---@field set_month fun(datetime:DateTime, month: number)
 ---@field set_day fun(datetime:DateTime, day: number)
@@ -23,36 +21,107 @@
 ---@field set_second fun(datetime:DateTime, sec: number)
 ---@field set_millisecond fun(datetime:DateTime, milli: number)
 ---@field set_epoch_milliseconds fun(datetime: DateTime, milli: number)
----@field to_date_string fun(datetime: DateTime): string?
----@field to_time_string fun(datetime: DateTime): string?
----@field to_datetime_string fun(datetime: DateTime): string?
----@field to_iso_string fun(datetime: DateTime): string?
----@field to_locale_date_string fun(datetime: DateTime): string?
----@field to_locale_time_string fun(datetime: DateTime): string?
----@field to_locale_datetime_string fun(datetime: DateTime): string?
+---@field to_utc fun(datetime: DateTime): DateTime
+---@field to_local fun(datetime: DateTime): DateTime
+---@field to_date_string fun(datetime: DateTime): string
+---@field to_time_string fun(datetime: DateTime): string
+---@field to_datetime_string fun(datetime: DateTime): string
+---@field to_iso_string fun(datetime: DateTime): string
+---@field to_locale_date_string fun(datetime: DateTime): string
+---@field to_locale_time_string fun(datetime: DateTime): string
+---@field to_locale_datetime_string fun(datetime: DateTime): string
 
-Astra.datetime = {}
+---@class DateTime
+local DateTimeWrapper = {}
+DateTimeWrapper.__index = DateTimeWrapper
 
----@return DateTime
-function Astra.datetime.new_now()
-	---@diagnostic disable-next-line: undefined-global
-	return astra_internal__datetime_new_now()
+-- ! THIS CAN BE REUSED AS A LIB
+local function create_proxy(wrapper_methods)
+	local mt = {}
+
+	mt.__index = function(self, key)
+		-- Wrapper methods override everything
+		if wrapper_methods[key] ~= nil then
+			return wrapper_methods[key]
+		end
+
+		-- Then any per-instance value
+		local val = rawget(self, key)
+		if val ~= nil then
+			return val
+		end
+
+		-- Fallback to underlying userdata/table
+		local underlying = rawget(self, "_obj")
+		local v = underlying[key]
+		if type(v) == "function" then
+			return function(_, ...)
+				return v(underlying, ...)
+			end
+		else
+			return v
+		end
+	end
+
+	mt.__newindex = function(self, key, value)
+		-- If wrapper defines it or instance has it—set on proxy
+		if wrapper_methods[key] ~= nil or rawget(self, key) ~= nil then
+			rawset(self, key, value)
+		else
+			local underlying = rawget(self, "_obj")
+			local setter = underlying["set_" .. key]
+			if type(setter) == "function" then
+				setter(underlying, value)
+			else
+				underlying[key] = value
+			end
+		end
+	end
+
+	mt.__tostring = function(self)
+		local u = rawget(self, "_obj")
+		return (u.to_string and u:to_string()) or tostring(u)
+	end
+
+	mt.__concat = function(a, b)
+		return tostring(a) .. tostring(b)
+	end
+
+	return mt
 end
 
----@return DateTime
-function Astra.datetime.new_utc_now()
-	---@diagnostic disable-next-line: undefined-global
-	return astra_internal__datetime_new_now(true)
+-- General wrapper factory
+local function wrap(obj, wrapper_methods)
+	assert(type(obj) == "userdata" or type(obj) == "table", "Can only wrap userdata or tables")
+	local proxy = { _obj = obj }
+	setmetatable(proxy, create_proxy(wrapper_methods or {}))
+	return proxy
 end
 
----@type fun(year: number, month: number?, day: number?, hour: number?, min: number?, sec: number?, milli: number?): DateTime
-function Astra.datetime.new_from(year, month, day, hour, min, sec, milli)
-	---@diagnostic disable-next-line: undefined-global
-	return astra_internal__datetime_new_from(year, month, date, hour, min, sec, milli, false)
+---@type fun(differentiator: string | number | nil, month: number?, day: number?, hour: number?, min: number?, sec: number?, milli: number?): DateTime
+---@param differentiator string | number | nil This field can be used to determine the type of DateTime. On empty it creates a new local DateTime, on number it starts te sequence for letting you define the DateTime by parameters, and on string it allows you to parse a string to DateTime.
+---@return DateTime
+local function new_datetime(differentiator, month, day, hour, min, sec, milli)
+	if type(differentiator) == "string" then
+		---@diagnostic disable-next-line: undefined-global
+		return astra_internal__datetime_new_parse(differentiator)
+	elseif type(differentiator) == "number" then
+		---@diagnostic disable-next-line: undefined-global
+		return astra_internal__datetime_new_from(differentiator, month, day, hour, min, sec, milli)
+	else
+		---@diagnostic disable-next-line: undefined-global
+		return astra_internal__datetime_new_now()
+	end
 end
 
----@type fun(year: number, month: number?, day: number?, hour: number?, min: number?, sec: number?, milli: number?): DateTime
-function Astra.datetime.new_utc_from(year, month, day, hour, min, sec, milli)
-	---@diagnostic disable-next-line: undefined-global
-	return astra_internal__datetime_new_from(year, month, date, hour, min, sec, milli, true)
+Astra.datetime = {}
+
+---@type fun(differentiator: string | number | nil, month: number?, day: number?, hour: number?, min: number?, sec: number?, milli: number?): DateTime
+---@param differentiator string | number | nil This field can be used to determine the type of DateTime. On empty it creates a new local DateTime, on number it starts te sequence for letting you define the DateTime by parameters, and on string it allows you to parse a string to DateTime.
+---@return DateTime
+--- Creates a wrapper for a DateTime-like object
+function Astra.datetime.new(differentiator, month, day, hour, min, sec, milli)
+	-- Create real DateTime using Astra.datetime
+	local real_dt = new_datetime(differentiator, month, day, hour, min, sec, milli)
+	return wrap(real_dt, DateTimeWrapper)
 end

src/components/datetime.rs

@@ -1,10 +1,10 @@
 use chrono::{offset::LocalResult, prelude::*};
-use mlua::UserData;
+use mlua::{FromLua, UserData};
 
+#[derive(Debug, Clone, FromLua)]
 pub struct LuaDateTime {
     dt: DateTime<FixedOffset>,
 }
-
 impl LuaDateTime {
     pub fn register_to_lua(lua: &mlua::Lua) -> mlua::Result<&'static str> {
         lua.globals().set(
@@ -19,6 +19,23 @@ impl LuaDateTime {
             })?,
         )?;
 
+        lua.globals().set(
+            "astra_internal__datetime_new_parse",
+            lua.create_function(|_, date_str: String| {
+                match DateTime::parse_from_rfc2822(&date_str) {
+                    Ok(dt) => Ok(Self { dt }),
+                    Err(err1) => match DateTime::parse_from_rfc3339(&date_str) {
+                        Ok(dt) => Ok(Self { dt }),
+                        Err(err2) => Err(mlua::Error::runtime(format!(
+                            "\nRFC 2822 ERR: {:?}\nRFC 3339 ERR: {:?}",
+                            err1.to_string(),
+                            err2.to_string()
+                        ))),
+                    },
+                }
+            })?,
+        )?;
+
         lua.globals().set(
             "astra_internal__datetime_new_from",
             lua.create_function(
@@ -121,6 +138,8 @@ impl UserData for LuaDateTime {
         add_getter_method!("get_timezone_offset", offset, |offset: &FixedOffset| offset
             .local_minus_utc()
             / 60);
+        add_getter_method!("to_rfc2822", to_rfc2822);
+        add_getter_method!("to_rfc3339", to_rfc3339);
 
         add_setter_method!("set_year", with_year, i32, "Invalid year!");
         add_setter_method!("set_month", with_month, u32, "Invalid month!");
@@ -148,6 +167,17 @@ impl UserData for LuaDateTime {
             }
         });
 
+        methods.add_method("to_utc", |_, this, _: ()| {
+            Ok(Self {
+                dt: this.dt.to_utc().fixed_offset(),
+            })
+        });
+        methods.add_method("to_local", |_, this, _: ()| {
+            let dt: DateTime<chrono::Local> = chrono::DateTime::from(this.dt);
+            Ok(Self {
+                dt: dt.fixed_offset(),
+            })
+        });
         add_formatted_method!("to_date_string", "%a %b %d %Y");
         add_formatted_method!("to_time_string", "%T %Z%z");
         add_formatted_method!("to_datetime_string", "%a %b %d %Y %T %Z%z");