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!')
+})

__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,27 @@
+use super::{Condition, Request};
+
+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)
+  }
+}

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

@@ -0,0 +1,113 @@
+use super::{Condition, Request};
+
+/// This provides logical grouping of conditions using either AND or OR
+/// combination behaviours.
+pub enum ConditionGroup<A, B>
+where
+  A: Condition + ?Sized,
+  B: Condition + ?Sized,
+{
+  Or(Box<A>, Box<B>),
+  And(Box<A>, Box<B>),
+}
+
+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),
+    }
+  }
+}
+
+#[cfg(test)]
+mod test {
+  use super::*;
+  use crate::rewrite::{ConditionExt, 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));
+  }
+}