Invalid range notation

Author: cpburnz

pathspec/patterns/gitignore/base.py

@@ -4,10 +4,14 @@
 
 import re
 
+from typing import (
+	Literal)
+
 from pathspec.pattern import (
 	RegexPattern)
 from pathspec._typing import (
-	AnyStr)  # Removed in 3.18.
+	AnyStr,  # Removed in 3.18.
+	assert_unreachable)
 
 _BYTES_ENCODING = 'latin1'
 """
@@ -55,14 +59,25 @@ def escape(s: AnyStr) -> AnyStr:
 			return out_string
 
 	@staticmethod
-	def _translate_segment_glob(pattern: str) -> str:
+	def _translate_segment_glob(
+		pattern: str,
+		range_error: Literal['literal', 'raise'],
+	) -> str:
 		"""
 		Translates the glob pattern to a regular expression. This is used in the
 		constructor to translate a path segment glob pattern to its corresponding
 		regular expression.
 
 		*pattern* (:class:`str`) is the glob pattern.
 
+		*range_error* (:class:`int`) is how to handle invalid range notation in the
+		pattern:
+
+		-	:data:`"literal"`: Invalid notation will be treated as a literal string.
+
+		-	:data:`"raise"`: Invalid notation will cause a :class:`_RangeError` to be
+			raised.
+
 		Returns the regular expression (:class:`str`).
 		"""
 		# NOTE: This is derived from `fnmatch.translate()` and is similar to the
@@ -96,9 +111,9 @@ def _translate_segment_glob(pattern: str) -> str:
 				regex += '[^/]'
 
 			elif char == '[':
-				# Bracket expression wildcard. Except for the beginning exclamation
-				# mark, the whole bracket expression can be used directly as regex, but
-				# we have to find where the expression ends.
+				# Bracket expression (range notation) wildcard. Except for the beginning
+				# exclamation mark, the whole bracket expression can be used directly as
+				# regex, but we have to find where the expression ends.
 				# - "[][!]" matches ']', '[' and '!'.
 				# - "[]-]" matches ']' and '-'.
 				# - "[!]a-]" matches any character except ']', 'a' and '-'.
@@ -152,9 +167,19 @@ def _translate_segment_glob(pattern: str) -> str:
 					i = j
 
 				else:
-					# Failed to find closing bracket, treat opening bracket as a bracket
-					# literal instead of as an expression.
-					regex += '\\['
+					# Failed to find closing bracket.
+					if range_error == 'literal':
+						# Treat opening bracket as a bracket literal instead of as an
+						# expression.
+						regex += '\\['
+					elif range_error == 'raise':
+						# Treat invalid range notation as an error.
+						raise _RangeError((
+							f"Invalid range notation={pattern[i:j]!r} found in pattern="
+							f"{pattern!r}."
+						))
+					else:
+						assert_unreachable(f"{range_error=!r} is invalid.")
 
 			else:
 				# Regular character, escape it for regex.
@@ -174,3 +199,11 @@ class GitIgnorePatternError(ValueError):
 	pattern.
 	"""
 	pass
+
+
+class _RangeError(GitIgnorePatternError):
+	"""
+	The :class:`_RangeError` class indicates an invalid range notation was found
+	in a gitignore pattern.
+	"""
+	pass

pathspec/patterns/gitignore/basic.py

@@ -293,7 +293,7 @@ def __translate_segments(cls, pattern_segs: list[str]) -> list[str]:
 
 				else:
 					# Match segment glob pattern.
-					out_parts.append(cls._translate_segment_glob(seg))
+					out_parts.append(cls._translate_segment_glob(seg, 'literal'))
 
 				if i == end:
 					if seg == '*':

pathspec/patterns/gitignore/spec.py

@@ -19,7 +19,8 @@
 from .base import (
 	GitIgnorePatternError,
 	_BYTES_ENCODING,
-	_GitIgnoreBasePattern)
+	_GitIgnoreBasePattern,
+	_RangeError)
 
 _DIR_MARK = 'ps_d'
 """
@@ -80,7 +81,7 @@ def __normalize_segments(
 		elif len(pattern_segs) == 1 or (len(pattern_segs) == 2 and not pattern_segs[1]):
 			# A single segment pattern with or without a trailing slash ('/') will
 			# match any descendant path. This is equivalent to "**/{pattern}". Prepend
-			# double-asterisk segment to make pattern relative to root.
+			# a double-asterisk segment to make the pattern relative to root.
 			if pattern_segs[0] != '**':
 				pattern_segs.insert(0, '**')
 
@@ -98,8 +99,8 @@ def __normalize_segments(
 		if not pattern_segs[-1]:
 			# A pattern ending with a slash ('/') will match all descendant paths if
 			# it is a directory but not if it is a regular file. This is equivalent to
-			# "{pattern}/**". Set empty last segment to a double-asterisk to include
-			# all descendants.
+			# "{pattern}/**". Set the empty last segment to a double-asterisk to
+			# include all descendants.
 			pattern_segs[-1] = '**'
 
 		# EDGE CASE: Collapse duplicate double-asterisk sequences (i.e., '**/**').
@@ -210,8 +211,8 @@ def pattern_to_regex(
 
 		if pattern_str.startswith('!'):
 			# A pattern starting with an exclamation mark ('!') negates the pattern
-			# (exclude instead of include). Escape the exclamation mark with a back
-			# slash to match a literal exclamation mark (i.e., '\!').
+			# (exclude instead of include). Escape the exclamation mark with a
+			# backslash to match a literal exclamation mark (i.e., '\!').
 			include = False
 			# Remove leading exclamation mark.
 			pattern_str = pattern_str[1:]
@@ -243,6 +244,9 @@ def pattern_to_regex(
 			# Build regular expression from pattern.
 			try:
 				regex_parts = cls.__translate_segments(is_dir_pattern, pattern_segs)
+			except _RangeError:
+				# EDGE CASE: Git discards patterns with range notation errors.
+				return (None, None)
 			except ValueError as e:
 				raise GitIgnorePatternError((
 					f"Invalid git pattern: {original_pattern!r}"
@@ -279,6 +283,8 @@ def __translate_segments(
 		*pattern_segs* (:class:`list` of :class:`str`) contains the pattern
 		segments.
 
+		Raises :class:`_RangeError` if invalid range notation is found.
+
 		Returns the regular expression parts (:class:`list` of :class:`str`).
 		"""
 		# Build regular expression from pattern.
@@ -322,7 +328,7 @@ def __translate_segments(
 
 				else:
 					# Match segment glob pattern.
-					out_parts.append(cls._translate_segment_glob(seg))
+					out_parts.append(cls._translate_segment_glob(seg, 'raise'))
 
 				if i == end:
 					# A pattern ending without a slash ('/') will match a file or a

tests/test_02_gitignore_basic.py

@@ -926,13 +926,23 @@ def test_15_issue_93_c_2_invalid(self):
 		# - See <https://github.com/cpburnz/python-pathspec/issues/93>.
 		for raw_pattern in [
 			'[!]',
-			'[z-a]',
-			'a[z-a]',
+			'a[!]',
 		]:
 			with self.subTest(f"p={raw_pattern!r}"):
 				pattern = GitIgnoreBasicPattern(raw_pattern)
 				self.assertIs(pattern.include, None)
-				self.assertIs(pattern.regex.pattern, None)
+				self.assertIs(pattern.regex, None)
+
+		# The `re` module fails to compile these.
+		# - NOTE: Technically, these should result in null patterns rather than
+		#   exceptions to fully replicate Git's behavior.
+		for raw_pattern in [
+			'[z-a]',
+			'a[z-a]',
+		]:
+			with self.subTest(f"p={raw_pattern!r}"):
+				with self.assertRaises(re.PatternError):
+					GitIgnoreBasicPattern(raw_pattern)
 
 	def test_15_issue_93_c_3_unclosed(self):
 		"""
@@ -954,7 +964,7 @@ def test_15_issue_93_c_3_unclosed(self):
 			with self.subTest(f"p={raw_pattern!r}"):
 				pattern = GitIgnoreBasicPattern(raw_pattern)
 				self.assertIs(pattern.include, None)
-				self.assertIs(pattern.regex.pattern, None)
+				self.assertIs(pattern.regex, None)
 
 	def test_16_repr_str(self):
 		"""

tests/test_03_gitignore_spec.py

@@ -928,13 +928,23 @@ def test_15_issue_93_c_2_invalid(self):
 		# - See <https://github.com/cpburnz/python-pathspec/issues/93>.
 		for raw_pattern in [
 			'[!]',
-			'[z-a]',
-			'a[z-a]',
+			'a[!]',
 		]:
 			with self.subTest(f"p={raw_pattern!r}"):
 				pattern = GitIgnoreSpecPattern(raw_pattern)
 				self.assertIs(pattern.include, None)
-				self.assertIs(pattern.regex.pattern, None)
+				self.assertIs(pattern.regex, None)
+
+		# The `re` module fails to compile these.
+		# - NOTE: Technically, these should result in null patterns rather than
+		#   exceptions to fully replicate Git's behavior.
+		for raw_pattern in [
+			'[z-a]',
+			'a[z-a]',
+		]:
+			with self.subTest(f"p={raw_pattern!r}"):
+				with self.assertRaises(re.PatternError):
+					GitIgnoreSpecPattern(raw_pattern)
 
 	def test_15_issue_93_c_3_unclosed(self):
 		"""
@@ -956,4 +966,4 @@ def test_15_issue_93_c_3_unclosed(self):
 			with self.subTest(f"p={raw_pattern!r}"):
 				pattern = GitIgnoreSpecPattern(raw_pattern)
 				self.assertIs(pattern.include, None)
-				self.assertIs(pattern.regex.pattern, None)
+				self.assertIs(pattern.regex, None)