rrule-rust 1.1.4 → 1.2.0-next.1

package/.releaserc

@@ -0,0 +1,47 @@
+{
+  "plugins": [
+    [
+      "@semantic-release/commit-analyzer",
+      {
+        "preset": "angular",
+        "releaseRules": [
+          { "type": "docs", "release": "patch" },
+          { "type": "perf", "release": "patch" },
+          { "type": "revert", "release": "patch" }
+        ]
+      }
+    ], 
+    [
+      "@semantic-release/release-notes-generator",
+      {
+        "parserOpts": {
+          "noteKeywords": ["BREAKING CHANGE", "BREAKING CHANGES", "BREAKING"]
+        },
+        "preset": "conventionalcommits",
+        "presetConfig": {
+          "types": [
+            { "type": "build", "section": "Build System", "hidden": false },
+            { "type": "chore", "section": "Build System", "hidden": false },
+            { "type": "chore", "scope": "merge", "section": "Build System", "hidden": true },
+            { "type": "ci", "section": "Continuous Integration", "hidden": false },
+            { "type": "docs", "section": "Documentation", "hidden": false },
+            { "type": "feat", "section": "Features", "hidden": false },
+            { "type": "fix", "section": "Bug Fixes", "hidden": false },
+            { "type": "perf", "section": "Performance Improvements", "hidden": false },
+            { "type": "refactor", "section": "Code Refactoring", "hidden": false },
+            { "type": "revert", "section": "Reverted Changes", "hidden": false },
+            { "type": "style", "section": "Styles", "hidden": false },
+            { "type": "test", "section": "Tests", "hidden": false }
+          ]
+        },
+        "writerOpts": {
+          "commitsSort": ["subject", "scope"]
+        }
+      }
+    ],
+    "@semantic-release/github", 
+    "@semantic-release/npm", 
+    "@semantic-release/git"
+  ],
+  "branches": ["+([0-9])?(.{+([0-9]),x}).x", "master", {"name": "next", "prerelease": true}]
+}

package/index.d.ts

@@ -77,6 +77,9 @@ export class RRuleSet {
   addExdate(timestamp: number): this
   get dtstart(): number
   get tzid(): string
+  getRrules(): Array<RRule>
+  getExrules(): Array<RRule>
+  getExdates(): Array<number>
   all(limit?: number | undefined | null): number[]
   between(after: number, before: number, inclusive?: boolean | undefined | null): number[]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rrule-rust",
-  "version": "1.1.4",
+  "version": "1.2.0-next.1",
   "main": "index.js",
   "types": "index.d.ts",
   "keywords": [
@@ -40,6 +40,7 @@
   "license": "MIT",
   "devDependencies": {
     "@napi-rs/cli": "^2.15.1",
+    "@semantic-release/git": "^10.0.1",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.15.5",
     "@typescript-eslint/eslint-plugin": "^5.50.0",
@@ -55,16 +56,17 @@
     "pre-commit": "^1.2.2",
     "prettier": "^2.8.3",
     "rrule": "^2.7.2",
+    "semantic-release": "^22.0.12",
     "ts-jest": "^29.0.5",
     "ts-node": "^10.9.1",
     "typescript": "^4.9.4"
   },
   "pre-commit": [
-    "lint:fix-staged",
-    "test"
+    "lint:fix-staged"
   ],
   "lint-staged": {
-    "**/*.{js,ts,json}": "eslint --fix --max-warnings=0"
+    "**/*.{js,ts,json}": "eslint --fix --max-warnings=0",
+    "**/*.rs": "rustfmt"
   },
   "engines": {
     "node": ">= 10"
@@ -78,24 +80,27 @@
     "universal": "napi universal",
     "version": "napi version",
     "benchmark": "ts-node ./benchmark/index.ts",
-    "lint": "eslint \"**/*.{js,ts,json}\" --max-warnings=0",
-    "lint:fix": "yarn lint --fix",
+    "lint": "cargo fmt --all -- --check && eslint \"**/*.{js,ts,json}\" --max-warnings=0",
+    "lint:fix": "cargo fmt --all && yarn lint --fix",
     "lint:fix-staged": "lint-staged"
   },
+  "dependencies": {
+    "conventional-changelog-conventionalcommits": "^7.0.2"
+  },
   "optionalDependencies": {
-    "@rrule-rust/lib-win32-x64-msvc": "1.1.4",
-    "@rrule-rust/lib-darwin-x64": "1.1.4",
-    "@rrule-rust/lib-linux-x64-gnu": "1.1.4",
-    "@rrule-rust/lib-darwin-arm64": "1.1.4",
-    "@rrule-rust/lib-android-arm64": "1.1.4",
-    "@rrule-rust/lib-linux-arm64-gnu": "1.1.4",
-    "@rrule-rust/lib-linux-arm64-musl": "1.1.4",
-    "@rrule-rust/lib-win32-arm64-msvc": "1.1.4",
-    "@rrule-rust/lib-linux-arm-gnueabihf": "1.1.4",
-    "@rrule-rust/lib-linux-x64-musl": "1.1.4",
-    "@rrule-rust/lib-freebsd-x64": "1.1.4",
-    "@rrule-rust/lib-win32-ia32-msvc": "1.1.4",
-    "@rrule-rust/lib-android-arm-eabi": "1.1.4",
-    "@rrule-rust/lib-darwin-universal": "1.1.4"
+    "@rrule-rust/lib-win32-x64-msvc": "1.2.0-next.1",
+    "@rrule-rust/lib-darwin-x64": "1.2.0-next.1",
+    "@rrule-rust/lib-linux-x64-gnu": "1.2.0-next.1",
+    "@rrule-rust/lib-darwin-arm64": "1.2.0-next.1",
+    "@rrule-rust/lib-android-arm64": "1.2.0-next.1",
+    "@rrule-rust/lib-linux-arm64-gnu": "1.2.0-next.1",
+    "@rrule-rust/lib-linux-arm64-musl": "1.2.0-next.1",
+    "@rrule-rust/lib-win32-arm64-msvc": "1.2.0-next.1",
+    "@rrule-rust/lib-linux-arm-gnueabihf": "1.2.0-next.1",
+    "@rrule-rust/lib-linux-x64-musl": "1.2.0-next.1",
+    "@rrule-rust/lib-freebsd-x64": "1.2.0-next.1",
+    "@rrule-rust/lib-win32-ia32-msvc": "1.2.0-next.1",
+    "@rrule-rust/lib-android-arm-eabi": "1.2.0-next.1",
+    "@rrule-rust/lib-darwin-universal": "1.2.0-next.1"
   }
 }

package/src/lib.rs

@@ -46,6 +46,36 @@ pub enum JsMonth {
   December,
 }
 
+fn to_unvalidated(rrule: &RRule) -> RRule<Unvalidated> {
+  let by_month = rrule
+    .get_by_month()
+    .iter()
+    .map(|m| Month::try_from(*m).unwrap())
+    .collect::<Vec<_>>();
+  let mut unvalidated = RRule::new(rrule.get_freq())
+    .interval(rrule.get_interval())
+    .week_start(rrule.get_week_start())
+    .by_set_pos(rrule.get_by_set_pos().to_vec())
+    .by_month(&by_month)
+    .by_month_day(rrule.get_by_month_day().to_vec())
+    .by_year_day(rrule.get_by_year_day().to_vec())
+    .by_week_no(rrule.get_by_week_no().to_vec())
+    .by_weekday(rrule.get_by_weekday().to_vec())
+    .by_hour(rrule.get_by_hour().to_vec())
+    .by_minute(rrule.get_by_minute().to_vec())
+    .by_second(rrule.get_by_second().to_vec());
+
+  if let Some(count) = rrule.get_count() {
+    unvalidated = unvalidated.count(count);
+  }
+
+  if let Some(until) = rrule.get_until() {
+    unvalidated = unvalidated.until(*until);
+  }
+
+  unvalidated
+}
+
 #[napi(js_name = "RRule")]
 pub struct JsRRule {
   rrule: RRule<Unvalidated>,
@@ -78,7 +108,7 @@ impl JsRRule {
   #[napi(getter, ts_return_type = "Weekday[]")]
   pub fn by_weekday(&self, env: Env) -> napi::Result<Array> {
     let ndays = self.rrule.get_by_weekday();
-    let mut arr = env.create_array(0).unwrap();
+    let mut arr = env.create_array(0)?;
 
     for nday in ndays.iter() {
       let day = match nday {
@@ -86,7 +116,7 @@ impl JsRRule {
         _ => panic!("Unsupported"),
       };
 
-      arr.insert(map_rust_weekday(day)).unwrap();
+      arr.insert(map_rust_weekday(day))?;
     }
 
     Ok(arr)
@@ -120,10 +150,10 @@ impl JsRRule {
   #[napi(getter, ts_return_type = "Month[]")]
   pub fn by_month(&self, env: Env) -> napi::Result<Array> {
     let months = self.rrule.get_by_month();
-    let mut arr = env.create_array(0).unwrap();
+    let mut arr = env.create_array(0)?;
 
     for month in months.iter() {
-      arr.insert(map_rust_month(month)).unwrap();
+      arr.insert(map_rust_month(month))?;
     }
 
     Ok(arr)
@@ -296,8 +326,14 @@ impl JsRRule {
     Ok(self)
   }
 
-  pub fn validate(&self, dt_start: DateTime<Tz>) -> RRule {
-    self.rrule.clone().validate(dt_start).unwrap()
+  pub fn validate(&self, dt_start: DateTime<Tz>) -> napi::Result<RRule> {
+    return Ok(
+      self
+        .rrule
+        .clone()
+        .validate(dt_start)
+        .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e))?,
+    );
   }
 }
 
@@ -310,21 +346,23 @@ pub struct JsRRuleSet {
 #[napi]
 impl JsRRuleSet {
   #[napi(constructor)]
-  pub fn new(dtstart: i64, tzid: String) -> Self {
-    let tz = map_js_tz(&tzid);
+  pub fn new(dtstart: i64, tzid: String) -> napi::Result<Self> {
+    let tz = map_js_tz(&tzid)?;
     let date = timestamp_to_date_with_tz(dtstart, &tz);
     let rrule_set = RRuleSet::new(date);
 
-    JsRRuleSet { rrule_set, tz }
+    Ok(JsRRuleSet { rrule_set, tz })
   }
 
   #[napi(factory, ts_return_type = "RRuleSet")]
-  pub fn parse(str: String) -> Self {
-    let rrule_set: RRuleSet = str.parse().unwrap();
+  pub fn parse(str: String) -> napi::Result<Self> {
+    let rrule_set: RRuleSet = str
+      .parse()
+      .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e))?;
     let dtstart = rrule_set.get_dt_start();
     let tz = dtstart.timezone();
 
-    JsRRuleSet { rrule_set, tz }
+    Ok(JsRRuleSet { rrule_set, tz })
   }
 
   #[napi]
@@ -335,7 +373,7 @@ impl JsRRuleSet {
   #[napi]
   pub fn add_rrule(&mut self, js_rrule: &JsRRule) -> napi::Result<&Self> {
     let dt_start = self.rrule_set.get_dt_start().clone();
-    let rrule = js_rrule.validate(dt_start);
+    let rrule = js_rrule.validate(dt_start)?;
 
     replace_with_or_abort(&mut self.rrule_set, |self_| self_.rrule(rrule));
 
@@ -344,7 +382,7 @@ impl JsRRuleSet {
 
   #[napi]
   pub fn add_exrule(&mut self, js_rrule: &JsRRule) -> napi::Result<&Self> {
-    let rrule = js_rrule.validate(*self.rrule_set.get_dt_start());
+    let rrule = js_rrule.validate(*self.rrule_set.get_dt_start())?;
 
     replace_with_or_abort(&mut self.rrule_set, |self_| self_.exrule(rrule));
 
@@ -370,19 +408,39 @@ impl JsRRuleSet {
     Ok(String::from(self.tz.name()))
   }
 
-  /*#[napi(ts_return_type="RRule[]")]
-  pub fn get_rrules(&self, env: Env) -> napi::Result<Array> {
-    let mut arr = env.create_array(0).unwrap();
-    let rrules = self.rrule_set.get_rrule();
+  #[napi]
+  pub fn get_rrules(&self) -> Vec<JsRRule> {
+    return self
+      .rrule_set
+      .get_rrule()
+      .iter()
+      .map(|rrule| JsRRule {
+        rrule: to_unvalidated(rrule),
+      })
+      .collect();
+  }
 
-    for rrule in rrules.iter() {
-      arr.insert(JsRRule {
-        freq: map_rust_frequency(rrule.get_freq())
-      }).unwrap();
-    }
+  #[napi]
+  pub fn get_exrules(&self) -> Vec<JsRRule> {
+    return self
+      .rrule_set
+      .get_exrule()
+      .iter()
+      .map(|rrule| JsRRule {
+        rrule: to_unvalidated(rrule),
+      })
+      .collect();
+  }
 
-    Ok(arr)
-  }*/
+  #[napi]
+  pub fn get_exdates(&self) -> Vec<i64> {
+    return self
+      .rrule_set
+      .get_exdate()
+      .iter()
+      .map(|date| date.timestamp_millis())
+      .collect();
+  }
 
   fn is_after(&self, timestamp: i64, after_timestamp: i64, inclusive: Option<bool>) -> bool {
     let inclusive = inclusive.unwrap_or(false);
@@ -410,7 +468,7 @@ impl JsRRuleSet {
 
   #[napi(ts_return_type = "number[]")]
   pub fn all(&self, env: Env, limit: Option<u32>) -> napi::Result<Array> {
-    let mut arr = env.create_array(0).unwrap();
+    let mut arr = env.create_array(0)?;
     let mut left = match limit {
       Some(number) => number,
       None => 0,
@@ -424,7 +482,7 @@ impl JsRRuleSet {
       }
 
       let timestamp = date.timestamp_millis();
-      arr.insert(timestamp).unwrap();
+      arr.insert(timestamp)?;
     }
 
     Ok(arr)
@@ -438,7 +496,7 @@ impl JsRRuleSet {
     before: i64,
     inclusive: Option<bool>,
   ) -> napi::Result<Array> {
-    let mut arr = env.create_array(0).unwrap();
+    let mut arr = env.create_array(0)?;
 
     for date in self.rrule_set.into_iter() {
       let timestamp = date.timestamp_millis();
@@ -446,7 +504,7 @@ impl JsRRuleSet {
       let is_before = self.is_before(timestamp, before, inclusive);
 
       if is_after && is_before {
-        arr.insert(timestamp).unwrap();
+        arr.insert(timestamp)?;
       } else if !is_before {
         break;
       }
@@ -480,15 +538,6 @@ fn map_js_frequency(freq: JsFrequency) -> Frequency {
   }
 }
 
-/*fn map_rust_rrule (rrule: RRule) -> JsRRule {
-  JsRRule {
-    freq: map_rust_frequency(rrule.get_freq()),
-    interval: Some(rrule.get_interval()),
-    count: rrule.get_count(),
-    by_weekday:
-  }
-}*/
-
 fn map_js_weekday(weekday: JsWeekday) -> Weekday {
   match weekday {
     JsWeekday::Monday => Weekday::Mon,
@@ -548,9 +597,11 @@ fn map_rust_month(month: &u8) -> JsMonth {
   }
 }
 
-fn map_js_tz(tz: &str) -> Tz {
-  let chrono_tz = tz.parse().unwrap();
-  Tz::Tz(chrono_tz)
+fn map_js_tz(tz: &str) -> napi::Result<Tz> {
+  let chrono_tz = tz
+    .parse()
+    .map_err(|e| napi::Error::new(napi::Status::GenericFailure, e))?;
+  Ok(Tz::Tz(chrono_tz))
 }
 
 fn timestamp_to_date_with_tz(timestamp: i64, tz: &Tz) -> DateTime<Tz> {