Refactor to make it possible to expose into JS properly.

Author: Qard

__test__/handler.spec.mjs

@@ -3,6 +3,7 @@ import test from 'ava'
 import { Php, Request } from '../index.js'
 
 import { MockRoot } from './util.mjs'
+import { Rewriter } from '../index.js'
 
 test('Support input/output streams', async (t) => {
   const mockroot = await MockRoot.from({
@@ -167,3 +168,42 @@ test('Allow receiving true errors', async (t) => {
     message: /^Script not found: .*\/index\.php$/
   }, 'should throw error')
 })
+
+test('Accept rewriter', async (t) => {
+  const mockroot = await MockRoot.from({
+    'index.php': '<?php echo "Hello, World!"; ?>'
+  })
+  t.teardown(() => mockroot.clean())
+
+  const rewrite = new Rewriter([
+    {
+      conditions: [
+        {
+          type: 'path',
+          args: ['^/rewrite_me$']
+        }
+      ],
+      rewriters: [
+        {
+          type: 'path',
+          args: ['^/rewrite_me$', '/index.php']
+        }
+      ]
+    }
+  ])
+
+  const php = new Php({
+    argv: process.argv,
+    docroot: mockroot.path,
+    throwRequestErrors: true,
+    rewrite
+  })
+
+  const req = new Request({
+    url: 'http://example.com/rewrite_me'
+  })
+
+  const res = await php.handleRequest(req)
+  t.is(res.status, 200)
+  t.is(res.body.toString('utf8'), 'Hello, World!')
+})

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

@@ -1,28 +1,27 @@
 use super::{Condition, Request};
 
-/// Support plain functions as conditions
 impl<F> Condition for F
 where
   F: Fn(&Request) -> bool + Sync + Send,
 {
+  /// Matches if calling the Fn(&Request) with the given request returns true
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// # use lang_handler::{Request, rewrite::Condition};
+  /// let condition = |request: &Request| {
+  ///   request.url().path().contains("/foo")
+  /// };
+  ///
+  /// let request = Request::builder()
+  ///   .url("http://example.com/index.php")
+  ///   .build()
+  ///   .expect("request should build");
+  ///
+  /// assert_eq!(condition.matches(&request), false);
+  /// ```
   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/existence.rs

@@ -0,0 +1,158 @@
+use std::path::PathBuf;
+
+use super::Condition;
+use super::Request;
+
+/// Match if request path exists
+#[derive(Clone, Debug)]
+pub struct ExistenceCondition(PathBuf);
+
+impl ExistenceCondition {
+  /// Construct an ExistenceCondition to check within a given base directory.
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// # use lang_handler::rewrite::{Condition, ExistenceCondition};
+  /// # use lang_handler::Request;
+  /// let condition = ExistenceCondition::new("/foo/bar");
+  /// ```
+  pub fn new<P>(base: P) -> Self
+  where
+    P: Into<PathBuf>,
+  {
+    Self(base.into())
+  }
+}
+
+impl Condition for ExistenceCondition {
+  /// A NonExistenceCondition matches a request if the path segment of the
+  /// request url does not exist in the provided base directory.
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// # use lang_handler::rewrite::{Condition, ExistenceCondition};
+  /// # use lang_handler::Request;
+  /// let condition = ExistenceCondition::new("/foo/bar");
+  ///
+  /// let request = Request::builder()
+  ///   .url("http://example.com/index.php")
+  ///   .build()
+  ///   .expect("should build request");
+  ///
+  /// assert_eq!(condition.matches(&request), false);
+  /// ```
+  fn matches(&self, request: &Request) -> bool {
+    self
+      .0
+      .join(request.url().path().strip_prefix("/").unwrap())
+      .canonicalize()
+      .is_ok()
+  }
+}
+
+/// Match if request path does not exist
+#[derive(Clone, Debug, Default)]
+pub struct NonExistenceCondition(PathBuf);
+
+impl NonExistenceCondition {
+  /// Construct a NonExistenceCondition to check within a given base directory.
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// # use lang_handler::rewrite::{Condition, NonExistenceCondition};
+  /// # use lang_handler::Request;
+  /// let condition = NonExistenceCondition::new("/foo/bar");
+  /// ```
+  pub fn new<P>(base: P) -> Self
+  where
+    P: Into<PathBuf>,
+  {
+    Self(base.into())
+  }
+}
+
+impl Condition for NonExistenceCondition {
+  /// A NonExistenceCondition matches a request if the path segment of the
+  /// request url does not exist in the provided base directory.
+  ///
+  /// # Examples
+  ///
+  /// ```
+  /// # use lang_handler::rewrite::{Condition, NonExistenceCondition};
+  /// # use lang_handler::Request;
+  /// let condition = NonExistenceCondition::new("/foo/bar");
+  ///
+  /// let request = Request::builder()
+  ///   .url("http://example.com/index.php")
+  ///   .build()
+  ///   .expect("should build request");
+  ///
+  /// assert!(condition.matches(&request));
+  /// ```
+  fn matches(&self, request: &Request) -> bool {
+    self
+      .0
+      .join(request.url().path().strip_prefix("/").unwrap())
+      .canonicalize()
+      .is_err()
+  }
+}
+
+#[cfg(test)]
+mod test {
+  use super::*;
+
+  use std::{
+    env::current_dir,
+    fs::File,
+    io::Write,
+    path::{Path, PathBuf},
+  };
+
+  struct TempFile(PathBuf);
+
+  impl TempFile {
+    fn new<P: AsRef<Path>, S: Into<String>>(path: P, contents: S) -> Self {
+      let mut file = File::create(path.as_ref()).unwrap();
+      file.write_all(contents.into().as_bytes()).unwrap();
+      Self(path.as_ref().to_owned())
+    }
+  }
+
+  impl Drop for TempFile {
+    fn drop(&mut self) {
+      std::fs::remove_file(&self.0).unwrap();
+    }
+  }
+
+  #[test]
+  fn test_existence_condition() {
+    let _temp = TempFile::new("exists.php", "<?php echo \"Hello, world!\"; ?>");
+
+    let cwd = current_dir().unwrap();
+    let condition = ExistenceCondition::new(cwd);
+
+    let request = Request::builder()
+      .url("http://example.com/exists.php")
+      .build()
+      .expect("request should build");
+
+    assert!(condition.matches(&request));
+  }
+
+  #[test]
+  fn test_non_existence_condition() {
+    let cwd = current_dir().unwrap();
+    let condition = NonExistenceCondition::new(cwd);
+
+    let request = Request::builder()
+      .url("http://example.com/does_not_exist.php")
+      .build()
+      .expect("request should build");
+
+    assert!(condition.matches(&request));
+  }
+}

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

@@ -2,34 +2,54 @@ 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),
+pub enum ConditionGroup<A, B>
+where
+  A: Condition + ?Sized,
+  B: Condition + ?Sized,
+{
+  Or(Box<A>, Box<B>),
+  And(Box<A>, Box<B>),
 }
 
-impl Condition for ConditionGroup<'_> {
+impl<A, B> ConditionGroup<A, B>
+where
+  A: Condition + ?Sized,
+  B: Condition + ?Sized,
+{
+  pub fn and(a: Box<A>, b: Box<B>) -> Box<Self> {
+    Box::new(ConditionGroup::And(a, b))
+  }
+
+  pub fn or(a: Box<A>, b: Box<B>) -> Box<Self> {
+    Box::new(ConditionGroup::Or(a, b))
+  }
+}
+
+impl<A, B> Condition for ConditionGroup<A, B>
+where
+  A: Condition + ?Sized,
+  B: Condition + ?Sized,
+{
   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)
+      ConditionGroup::And(a, b) => a.matches(request) && b.matches(request),
     }
   }
 }
 
 #[cfg(test)]
 mod test {
   use super::*;
-  use crate::rewrite::{HeaderCondition, PathCondition};
+  use crate::rewrite::{ConditionExt, HeaderCondition, PathCondition};
 
   #[test]
   fn test_condition_group_and() {
-    let header = HeaderCondition::new("TEST", "^foo$")
-      .expect("should be valid regex");
+    let header = HeaderCondition::new("TEST", "^foo$").expect("should be valid regex");
 
-    let path = PathCondition::new("^/index\\.php$")
-      .expect("should be valid regex");
+    let path = PathCondition::new("^/index\\.php$").expect("should be valid regex");
 
-    let header_and_path = header.and(&path);
+    let header_and_path = header.and(path);
 
     // Check it matches when all conditions match
     let request = Request::builder()
@@ -59,13 +79,11 @@ mod test {
 
   #[test]
   fn test_condition_group_or() {
-    let header = HeaderCondition::new("TEST", "^foo$")
-      .expect("should be valid regex");
+    let header = HeaderCondition::new("TEST", "^foo$").expect("should be valid regex");
 
-    let path = PathCondition::new("^/index\\.php$")
-      .expect("should be valid regex");
+    let path = PathCondition::new("^/index\\.php$").expect("should be valid regex");
 
-    let header_or_path = header.or(&path);
+    let header_or_path = header.or(path);
 
     // Check it matches when either condition matches
     let request = Request::builder()
@@ -83,13 +101,13 @@ mod test {
       .build()
       .expect("request should build");
 
-    assert!(!header_or_path.matches(&only_header));
+    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));
+    assert!(header_or_path.matches(&only_url));
   }
 }

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

@@ -15,15 +15,15 @@ pub struct HeaderCondition {
 impl HeaderCondition {
   /// Construct a new HeaderCondition matching the given header name and Regex
   /// pattern.
-  pub fn new<S, R>(name: S, pattern: R) -> Result<Self, Error>
+  pub fn new<S, R>(name: S, pattern: R) -> Result<Box<Self>, Error>
   where
     S: Into<String>,
     R: TryInto<Regex>,
     Error: From<<R as TryInto<Regex>>::Error>,
   {
     let name = name.into();
     let pattern = pattern.try_into()?;
-    Ok(Self { name, pattern })
+    Ok(Box::new(Self { name, pattern }))
   }
 }
 
@@ -45,8 +45,7 @@ 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/")