wip

Author: Qard

__test__/rewriter.spec.mjs

@@ -11,6 +11,25 @@ test('rewrites URLs', (t) => {
     }
   })
 
+  const config = {
+    condition: {
+      $and: [
+        {
+          type: 'path',
+          args: ['^/index.php$']
+        },
+        {
+          type: 'header',
+          args: ['TEST', '^foo$']
+        }
+      ]
+    },
+    rewrite: {
+      type: 'path',
+      args: ['^(/index.php)$', '/foo$1']
+    }
+  }
+
   const rewriter = new Rewriter([
     {
       operation: 'and',

crates/lang_handler/src/rewrite/condition/closure.rs

@@ -0,0 +1,28 @@
+use super::{Condition, Request};
+
+/// Support plain functions as conditions
+impl<F> Condition for F
+where
+  F: Fn(&Request) -> bool + Sync + Send,
+{
+  fn matches(&self, request: &Request) -> bool {
+    self(request)
+  }
+}
+
+#[cfg(test)]
+mod test {
+  use super::*;
+
+  #[test]
+  fn test_closure_condition() {
+    let condition = |_: &Request| true;
+
+    let request = Request::builder()
+      .url("http://example.com/index.php")
+      .build()
+      .expect("request should build");
+
+    assert!(condition.matches(&request));
+  }
+}

crates/lang_handler/src/rewrite/condition/group.rs

@@ -0,0 +1,95 @@
+use super::{Condition, Request};
+
+/// This provides logical grouping of conditions using either AND or OR
+/// combination behaviours.
+pub enum ConditionGroup<'a> {
+  Or(&'a dyn Condition, &'a dyn Condition),
+  And(&'a dyn Condition, &'a dyn Condition),
+}
+
+impl Condition for ConditionGroup<'_> {
+  fn matches(&self, request: &Request) -> bool {
+    match self {
+      ConditionGroup::Or(a, b) => a.matches(request) || b.matches(request),
+      ConditionGroup::And(a, b) => a.matches(request) && b.matches(request)
+    }
+  }
+}
+
+#[cfg(test)]
+mod test {
+  use super::*;
+  use crate::rewrite::{HeaderCondition, PathCondition};
+
+  #[test]
+  fn test_condition_group_and() {
+    let header = HeaderCondition::new("TEST", "^foo$")
+      .expect("should be valid regex");
+
+    let path = PathCondition::new("^/index\\.php$")
+      .expect("should be valid regex");
+
+    let header_and_path = header.and(&path);
+
+    // Check it matches when all conditions match
+    let request = Request::builder()
+      .url("http://example.com/index.php")
+      .header("TEST", "foo")
+      .build()
+      .expect("request should build");
+
+    assert!(header_and_path.matches(&request));
+
+    // Check it _does not_ match if either condition does not match
+    let only_header = Request::builder()
+      .url("http://example.com/nope.php")
+      .header("TEST", "foo")
+      .build()
+      .expect("request should build");
+
+    assert!(!header_and_path.matches(&only_header));
+
+    let only_url = Request::builder()
+      .url("http://example.com/index.php")
+      .build()
+      .expect("request should build");
+
+    assert!(!header_and_path.matches(&only_url));
+  }
+
+  #[test]
+  fn test_condition_group_or() {
+    let header = HeaderCondition::new("TEST", "^foo$")
+      .expect("should be valid regex");
+
+    let path = PathCondition::new("^/index\\.php$")
+      .expect("should be valid regex");
+
+    let header_or_path = header.or(&path);
+
+    // Check it matches when either condition matches
+    let request = Request::builder()
+      .url("http://example.com/index.php")
+      .header("TEST", "foo")
+      .build()
+      .expect("request should build");
+
+    assert!(header_or_path.matches(&request));
+
+    // Check it matches if either condition does not match
+    let only_header = Request::builder()
+      .url("http://example.com/nope.php")
+      .header("TEST", "foo")
+      .build()
+      .expect("request should build");
+
+    assert!(!header_or_path.matches(&only_header));
+
+    let only_url = Request::builder()
+      .url("http://example.com/index.php")
+      .build()
+      .expect("request should build");
+
+    assert!(!header_or_path.matches(&only_url));
+  }
+}

crates/lang_handler/src/rewrite/condition/header.rs

@@ -5,7 +5,7 @@ use regex::{Error, Regex};
 use super::Condition;
 use crate::Request;
 
-/// Match request header to a regex pattern
+/// Matches a request header to a regex pattern
 #[derive(Clone, Debug)]
 pub struct HeaderCondition {
   name: String,
@@ -45,7 +45,8 @@ mod test {
 
   #[test]
   fn test_header_condition() {
-    let condition = HeaderCondition::new("TEST", "^foo$").expect("regex should be valid");
+    let condition = HeaderCondition::new("TEST", "^foo$")
+      .expect("regex should be valid");
 
     let request = Request::builder()
       .url("http://example.com/")

crates/lang_handler/src/rewrite/condition/mod.rs

@@ -1,48 +1,75 @@
+mod closure;
+mod group;
 mod header;
 mod path;
-mod set;
 
-pub use header::*;
-pub use path::*;
-pub use set::*;
+use crate::Request;
 
-use super::Request;
-
-///
-/// Conditions
-///
+pub use group::ConditionGroup;
+pub use header::HeaderCondition;
+pub use path::PathCondition;
 
 /// A Condition is used to match against request state before deciding to apply
 /// a given Rewrite or set of Rewrites.
 pub trait Condition: Sync + Send {
   /// A Condition must implement a `matches(request) -> bool` method which
   /// receives a request object to determine if the condition is met.
   fn matches(&self, request: &Request) -> bool;
-}
 
-/// Support plain functions as conditions
-impl<F> Condition for F
-where
-  F: Fn(&Request) -> bool + Sync + Send,
-{
-  fn matches(&self, request: &Request) -> bool {
-    self(request)
+  /// Make a new condition which must pass both conditions
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// use lang_handler::rewrite::{PathCondition, HeaderCondition};
+  ///
+  /// let path = PathCondition::new("^/index.php$")
+  ///   .expect("should be valid regex");
+  ///
+  /// let header = HeaderCondition::new("TEST", "^foo$")
+  ///   .expect("should be valid regex");
+  ///
+  /// let path_and_header = path.and(header);
+  ///
+  /// let request = Request::builder()
+  ///   .url("http://example.com/index.php")
+  ///   .header("TEST", "foo")
+  ///   .build()
+  ///   .expect("should build request");
+  ///
+  /// assert_eq!(path_and_header.matches(request));
+  /// ```
+  fn and<'a>(&'a self, other: &'a impl Condition) -> ConditionGroup<'a>
+    where Self: std::marker::Sized
+  {
+    ConditionGroup::And(self, other)
   }
-}
-
-#[cfg(test)]
-mod test {
-  use super::*;
-
-  #[test]
-  fn test_closure_condition() {
-    let condition = |_: &Request| true;
-
-    let request = Request::builder()
-      .url("http://example.com/index.php")
-      .build()
-      .expect("request should build");
 
-    assert!(condition.matches(&request));
+  /// Make a new condition which must pass either condition
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// use lang_handler::rewrite::{PathCondition, HeaderCondition};
+  ///
+  /// let path = PathCondition::new("^/index.php$")
+  ///   .expect("should be valid regex");
+  ///
+  /// let header = HeaderCondition::new("TEST", "^foo$")
+  ///   .expect("should be valid regex");
+  ///
+  /// let path_or_header = path.or(header);
+  ///
+  /// let request = Request::builder()
+  ///   .url("http://example.com/index.php")
+  ///   .build()
+  ///   .expect("should build request");
+  ///
+  /// assert_eq!(path_or_header.matches(request));
+  /// ```
+  fn or<'a>(&'a self, other: &'a impl Condition) -> ConditionGroup<'a>
+    where Self: std::marker::Sized
+  {
+    ConditionGroup::Or(self, other)
   }
 }

crates/lang_handler/src/rewrite/condition/path.rs

@@ -37,7 +37,8 @@ mod test {
 
   #[test]
   fn test_path_condition() {
-    let condition = PathCondition::new("^/index.php$").expect("regex should be valid");
+    let condition = PathCondition::new("^/index.php$")
+      .expect("regex should be valid");
 
     let request = Request::builder()
       .url("http://example.com/index.php")