echocat#20 Added path_content_type_combination parameter to make it possible to decide if the user wants and/or and set it by default to and.

Author: blaubaer

README.md

@@ -19,10 +19,11 @@ This could be useful to modify static HTML files to add (for example) Google Ana
 
 ```
 filter rule {
-    path           <regexp pattern>
-    content_type   <regexp pattern> 
-    search_pattern <regexp pattern>
-    replacement    <replacement pattern>
+    path                          <regexp pattern>
+    content_type                  <regexp pattern>
+    path_content_type_combination <and|or>
+    search_pattern                <regexp pattern>
+    replacement                   <replacement pattern>
 }
 filter rule ...
 filter max_buffer_size    <maximum buffer size in bytes>
@@ -31,8 +32,11 @@ filter max_buffer_size    <maximum buffer size in bytes>
 * **rule**: Defines a new filter rule for a file to respond.
     > **Important:** Define ``path`` and/or ``content_type`` not to open. Slack rules could dramatically impact the system performance because every response is recorded to memory before returning it.
 
+    > **Hint:** Since version 0.8 are ``path`` and ``content_type`` are `and` combined if both provided. Before it was `or` combined but this was an unexpected
+
     * **path**: Regular expression that matches the requested path.
     * **content_type**: Regular expression that matches the requested content type that results after the evaluation of the whole request.
+    * **path_content_type_combination**: _(Since 0.8)_ Could be `and` or `or`. (Default: `and` - before this parameter existed it was `or`)
     * **search_pattern**: Regular expression to find in the response body to replace it.
     * **replacement**: Pattern to replace the ``search_pattern`` with. 
         <br>You can use parameters. Each parameter must be formatted like: ``{name}``.

init.go

@@ -85,13 +85,16 @@ func evalRule(controller *caddy.Controller, args []string, target *filterHandler
 		return controller.Errf("No more arguments for filter block 'rule' supported.")
 	}
 	targetRule := new(rule)
+	targetRule.pathAndContentTypeCombination = pathAndContentTypeAndCombination
 	for controller.NextBlock() {
 		optionName := controller.Val()
 		switch optionName {
 		case "path":
 			err = evalPath(controller, targetRule)
 		case "content_type":
 			err = evalContentType(controller, targetRule)
+		case "path_content_type_combination":
+			err = evalPathAndContentTypeCombination(controller, targetRule)
 		case "search_pattern":
 			err = evalSearchPattern(controller, targetRule)
 		case "replacement":
@@ -127,6 +130,18 @@ func evalContentType(controller *caddy.Controller, target *rule) error {
 	})
 }
 
+func evalPathAndContentTypeCombination(controller *caddy.Controller, target *rule) error {
+	return evalSimpleOption(controller, func(plainValue string) error {
+		for _, candidate := range possiblePathAndContentTypeCombination {
+			if string(candidate) == plainValue {
+				target.pathAndContentTypeCombination = candidate
+				return nil
+			}
+		}
+		return controller.Errf("Illegal value for 'path_content_type_combination': %v", plainValue)
+	})
+}
+
 func evalSearchPattern(controller *caddy.Controller, target *rule) error {
 	return evalRegexpOption(controller, func(value *regexp.Regexp) error {
 		target.searchPattern = value

init_test.go

@@ -28,10 +28,42 @@ func (s *initTest) Test_setup(c *C) {
 	r := handler.rules[0]
 	c.Assert(r.path.String(), Equals, "myPath")
 	c.Assert(r.contentType.String(), Equals, "myContentType")
+	c.Assert(r.pathAndContentTypeCombination, Equals, pathAndContentTypeAndCombination)
 	c.Assert(r.searchPattern.String(), Equals, "mySearchPattern")
 	c.Assert(string(r.replacement), Equals, "myReplacement")
 }
 
+func (s *initTest) Test_parseConfiguration_withPathAndContentTypeCombination(c *C) {
+	controller := s.newControllerFor("filter rule {\npath myPath\ncontent_type myContentType\nsearch_pattern mySearchPattern\nreplacement myReplacement\n}\n")
+	err := setup(controller)
+	c.Assert(err, IsNil)
+	handler, ok := httpserver.GetConfig(controller).Middleware()[0](newMockHandler("moo", 200)).(*filterHandler)
+	c.Assert(ok, Equals, true)
+	c.Assert(len(handler.rules), Equals, 1)
+	c.Assert(handler.rules[0].pathAndContentTypeCombination, Equals, pathAndContentTypeAndCombination)
+
+	controller = s.newControllerFor("filter rule {\npath_content_type_combination or\npath myPath\ncontent_type myContentType\nsearch_pattern mySearchPattern\n}\n")
+	err = setup(controller)
+	c.Assert(err, IsNil)
+	handler, ok = httpserver.GetConfig(controller).Middleware()[0](newMockHandler("moo", 200)).(*filterHandler)
+	c.Assert(ok, Equals, true)
+	c.Assert(len(handler.rules), Equals, 1)
+	c.Assert(handler.rules[0].pathAndContentTypeCombination, Equals, pathAndContentTypeOrCombination)
+
+	controller = s.newControllerFor("filter rule {\npath_content_type_combination and\npath myPath\ncontent_type myContentType\nsearch_pattern mySearchPattern\n}\n")
+	err = setup(controller)
+	c.Assert(err, IsNil)
+	handler, ok = httpserver.GetConfig(controller).Middleware()[0](newMockHandler("moo", 200)).(*filterHandler)
+	c.Assert(ok, Equals, true)
+	c.Assert(len(handler.rules), Equals, 1)
+	c.Assert(handler.rules[0].pathAndContentTypeCombination, Equals, pathAndContentTypeAndCombination)
+
+	controller = s.newControllerFor("filter rule {\npath_content_type_combination foo\npath myPath\ncontent_type myContentType\nsearch_pattern mySearchPattern\n}\n")
+	err = setup(controller)
+	c.Assert(err, NotNil)
+	c.Assert(err.Error(), Equals, "Testfile:2 - Parse error: Illegal value for 'path_content_type_combination': foo")
+}
+
 func (s *initTest) Test_parseConfiguration_directNamed(c *C) {
 	handler, err := parseConfiguration(s.newControllerFor("filter rule {\npath myPath\ncontent_type myContentType\nsearch_pattern mySearchPattern\nreplacement myReplacement\n}\n"))
 	c.Assert(err, IsNil)

rule.go

@@ -6,22 +6,57 @@ import (
 )
 
 type rule struct {
-	path          *regexp.Regexp
-	contentType   *regexp.Regexp
-	searchPattern *regexp.Regexp
-	replacement   []byte
+	path                          *regexp.Regexp
+	contentType                   *regexp.Regexp
+	pathAndContentTypeCombination pathAndContentTypeCombination
+	searchPattern                 *regexp.Regexp
+	replacement                   []byte
 }
 
-func (instance *rule) matches(request *http.Request, responseHeader *http.Header) bool {
-	if instance.path != nil && request != nil && instance.path.MatchString(request.URL.Path) {
-		return true
+type pathAndContentTypeCombination string
+
+const (
+	pathAndContentTypeAndCombination = pathAndContentTypeCombination("and")
+	pathAndContentTypeOrCombination  = pathAndContentTypeCombination("or")
+)
+
+var possiblePathAndContentTypeCombination = []pathAndContentTypeCombination{
+	pathAndContentTypeAndCombination,
+	pathAndContentTypeOrCombination,
+}
+
+func (instance rule) evaluatePathAndContentTypeResult(pathMatch bool, contentTypeMatch bool) bool {
+	combination := instance.pathAndContentTypeCombination
+	if combination == pathAndContentTypeCombination("") {
+		combination = pathAndContentTypeAndCombination
 	}
-	if instance.contentType != nil && responseHeader != nil && instance.contentType.MatchString(responseHeader.Get("Content-Type")) {
-		return true
+	if combination == pathAndContentTypeAndCombination {
+		return pathMatch && contentTypeMatch
+	}
+	if combination == pathAndContentTypeOrCombination {
+		return pathMatch || contentTypeMatch
 	}
 	return false
 }
 
+func (instance *rule) matches(request *http.Request, responseHeader *http.Header) bool {
+	var pathMatch, contentTypeMatch bool
+
+	if instance.path != nil {
+		pathMatch = request != nil && instance.path.MatchString(request.URL.Path)
+	} else {
+		pathMatch = true
+	}
+
+	if instance.contentType != nil {
+		contentTypeMatch = responseHeader != nil && instance.contentType.MatchString(responseHeader.Get("Content-Type"))
+	} else {
+		contentTypeMatch = true
+	}
+
+	return instance.evaluatePathAndContentTypeResult(pathMatch, contentTypeMatch)
+}
+
 func (instance *rule) execute(request *http.Request, responseHeader *http.Header, input []byte) []byte {
 	pattern := instance.searchPattern
 	if pattern == nil {

rule_test.go

@@ -47,21 +47,54 @@ func (s *ruleTest) Test_matches_contentType(c *C) {
 	c.Assert(r.matches(nil, &header), Equals, false)
 }
 
-func (s *ruleTest) Test_matches_combined(c *C) {
+func (s *ruleTest) Test_matches_and_combined(c *C) {
 	req := &http.Request{}
 	header := http.Header{}
 	r := &rule{
-		path:        regexp.MustCompile(".*\\.html"),
-		contentType: regexp.MustCompile("text/html.*"),
+		path:                          regexp.MustCompile(".*\\.html"),
+		contentType:                   regexp.MustCompile("text/html.*"),
+		pathAndContentTypeCombination: pathAndContentTypeAndCombination,
 	}
 
 	req.URL = testUrl1
 	header.Set("Content-Type", "text/html")
 	c.Assert(r.matches(req, &header), Equals, true)
+	c.Assert(r.matches(nil, &header), Equals, false)
+	c.Assert(r.matches(req, nil), Equals, false)
 
 	req.URL = testUrl2
-	header.Del("Content-Type")
-	c.Assert(r.matches(nil, &header), Equals, false)
+	c.Assert(r.matches(req, &header), Equals, false)
+
+	req.URL = testUrl1
+	header.Set("Content-Type", "text/plain")
+	c.Assert(r.matches(req, &header), Equals, false)
+}
+
+func (s *ruleTest) Test_matches_or_combined(c *C) {
+	req := &http.Request{}
+	header := http.Header{}
+	r := &rule{
+		path:                          regexp.MustCompile(".*\\.html"),
+		contentType:                   regexp.MustCompile("text/html.*"),
+		pathAndContentTypeCombination: pathAndContentTypeOrCombination,
+	}
+
+	req.URL = testUrl1
+	header.Set("Content-Type", "text/html")
+	c.Assert(r.matches(req, &header), Equals, true)
+	c.Assert(r.matches(nil, &header), Equals, true)
+	c.Assert(r.matches(req, nil), Equals, true)
+	c.Assert(r.matches(nil, nil), Equals, false)
+
+	req.URL = testUrl2
+	c.Assert(r.matches(req, &header), Equals, true)
+
+	req.URL = testUrl1
+	header.Set("Content-Type", "text/plain")
+	c.Assert(r.matches(req, &header), Equals, true)
+
+	req.URL = testUrl2
+	c.Assert(r.matches(req, &header), Equals, false)
 }
 
 func (s *ruleTest) Test_execute(c *C) {