1165765906

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/casbin/pycasbin/commit/<a class=hub.com/casbin/pycasbin/commit/<a class="double-link" href="https://git"><a class=hub.com/casbin/pycasbin/commit/<a class="double-link" href="https://git"><a class=hub.com/casbin/pycasbin/commit/<a class="double-link" href="https://git"><a class=hub.com/casbin/pycasbin/commit/<a class="double-link" href="https://git"><a class=hub.com/casbin/pycasbin/commit/226b7b0b2f1cccd6af64822b538db364750997aa">226b7b0b2">&lt;a href=&quot;https://github.com/casbin/pycasbin/commit/</a><a class="double-link" href="https://github.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/casbin/pycasbin/commit/226b7b0b2f1cccd6af64822b538db364750997aa">226b7b0b2</a><a href="https://github.com/casbin/pycasbin/commit/226b7b0b2f1cccd6af64822b538db364750997aa">&lt;a href=&quot;https://github.com/casbin/pycasbin/commit/226b7b0b2f1cccd6af64822b538db364750997aa&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/casbin/pycasbin/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/casbin/pycasbin/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/casbin/pycasbin/commit/226b7b0b2f1cccd6af64822b538db364750997aa&amp;quot;&amp;gt;226b7b0b2&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/casbin/pycasbin/commit/226b7b0b2f1cccd6af64822b538db364750997aa&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/casbin/pycasbin/commit/226b7b0b2f1cccd6af64822b538db364&amp;lt;/a&amp;gt;750</a>997aa&quot;&gt;&amp;quot;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/casbin/pycasbin/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/casbin/pycasbin/commit/387c6bf33&quot;&gt;387c6bf33&lt;/a&gt;&lt;a href=&quot;htt... (continued)

Pull Request Pull Request #183: feat: key_match4 builtin operator added

Run Details

25 of 26 new or added lines in 1 file covered. (96.15%)

1649 of 1958 relevant lines covered (84.22%)

10.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.88

/casbin/util/builtin_operators.py

import ipaddress
import re

from wcmatch import pathlib

KEY_MATCH2_PATTERN = re.compile(r"(.*?):[^\/]+(.*?)")
KEY_MATCH3_PATTERN = re.compile(r"(.*?){[^\/]+}(.*?)")
KEY_MATCH4_PATTERN = re.compile(r"{([^/]+)}")


def key_match(key1, key2):
    """determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
    For example, "/foo/bar" matches "/foo/*"
    """

    i = key2.find("*")
    if i == -1:
        return key1 == key2

    if len(key1) > i:
        return key1[:i] == key2[:i]
    return key1 == key2[:i]


def key_match_func(*args):
    """The wrapper for key_match."""
    name1 = args[0]
    name2 = args[1]

    return key_match(name1, name2)


def key_match2(key1, key2):
    """determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
    For example, "/foo/bar" matches "/foo/*", "/resource1" matches "/:resource"
    """

    key2 = key2.replace("/*", "/.*")
    key2 = KEY_MATCH2_PATTERN.sub(r"\g<1>[^\/]+\g<2>", key2, 0)

    if key2 == "*":
        key2 = "(.*)"

    return regex_match(key1, "^" + key2 + "$")


def key_match2_func(*args):
    name1 = args[0]
    name2 = args[1]

    return key_match2(name1, name2)


def key_match3(key1, key2):
    """determines determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
    For example, "/foo/bar" matches "/foo/*", "/resource1" matches "/{resource}"
    """

    key2 = key2.replace("/*", "/.*")
    key2 = KEY_MATCH3_PATTERN.sub(r"\g<1>[^\/]+\g<2>", key2, 0)

    return regex_match(key1, "^" + key2 + "$")


def key_match3_func(*args):
    name1 = args[0]
    name2 = args[1]

    return key_match3(name1, name2)


def key_match4(key1: str, key2: str) -> bool:
    """
    key_match4 determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
    Besides what key_match3 does, key_match4 can also match repeated patterns:
    "/parent/123/child/123" matches "/parent/{id}/child/{id}"
    "/parent/123/child/456" does not match "/parent/{id}/child/{id}"
    But key_match3 will match both.
    """
    key2 = key2.replace("/*", "/.*")

    tokens: [str] = []

    def repl(matchobj):
        tokens.append(matchobj.group(1))
        return "([^/]+)"

    key2 = KEY_MATCH4_PATTERN.sub(repl, key2)

    regexp = re.compile("^" + key2 + "$")
    matches = regexp.match(key1)

    if matches is None:
        return False
    if len(tokens) != len(matches.groups()):
        raise Exception("KeyMatch4: number of tokens is not equal to number of values")

    tokens_matches = dict()

    for i in range(len(tokens)):
        token, match = tokens[i], matches.groups()[i]

        if token not in tokens_matches.keys():
            tokens_matches[token] = match
        else:
            if tokens_matches[token] != match:
                return False
    return True


def key_match4_func(*args) -> bool:
    """
    key_match4_func is the wrapper for key_match4.
    """
    name1 = args[0]
    name2 = args[1]

    return key_match4(name1, name2)


def regex_match(key1, key2):
    """determines whether key1 matches the pattern of key2 in regular expression."""

    res = re.match(key2, key1)
    if res:
        return True
    else:
        return False


def regex_match_func(*args):
    """the wrapper for RegexMatch."""

    name1 = args[0]
    name2 = args[1]

    return regex_match(name1, name2)


def glob_match(string, pattern):
    """determines whether string matches the pattern in glob expression."""
    return pathlib.Path(string).globmatch(pattern)


def glob_match_func(*args):
    """the wrapper for globMatch."""

    string = args[0]
    pattern = args[1]

    return glob_match(string, pattern)


def ip_match(ip1, ip2):
    """IPMatch determines whether IP address ip1 matches the pattern of IP address ip2, ip2 can be an IP address or a CIDR pattern.
    For example, "192.168.2.123" matches "192.168.2.0/24"
    """
    ip1 = ipaddress.ip_address(ip1)
    try:
        network = ipaddress.ip_network(ip2, strict=False)
        return ip1 in network
    except ValueError:
        return ip1 == ip2


def ip_match_func(*args):
    """the wrapper for IPMatch."""

    ip1 = args[0]
    ip2 = args[1]

    return ip_match(ip1, ip2)


def generate_g_function(rm):
    """the factory method of the g(_, _) function."""

    def f(*args):
        name1 = args[0]
        name2 = args[1]

        if not rm:
            return name1 == name2
        elif 2 == len(args):
            return rm.has_link(name1, name2)
        else:
            domain = str(args[2])
            return rm.has_link(name1, name2, domain)

    return f

1	import ipaddress	12✔
2	import re	12✔
3
4	from wcmatch import pathlib	12✔
5
6	KEY_MATCH2_PATTERN = re.compile(r"(.?):[^\/]+(.?)")	12✔
7	KEY_MATCH3_PATTERN = re.compile(r"(.?){[^\/]+}(.?)")	12✔
8	KEY_MATCH4_PATTERN = re.compile(r"{([^/]+)}")	12✔
9
10
11	def key_match(key1, key2):	12✔
12	"""determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
13	For example, "/foo/bar" matches "/foo/*"
14	"""
15
16	i = key2.find("*")	12✔
17	if i == -1:	12✔
18	return key1 == key2	12✔
19
20	if len(key1) > i:	12✔
21	return key1[:i] == key2[:i]	12✔
22	return key1 == key2[:i]	12✔
23
24
25	def key_match_func(*args):	12✔
26	"""The wrapper for key_match."""
27	name1 = args[0]	12✔
28	name2 = args[1]	12✔
29
30	return key_match(name1, name2)	12✔
31
32
33	def key_match2(key1, key2):	12✔
34	"""determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
35	For example, "/foo/bar" matches "/foo/*", "/resource1" matches "/:resource"
36	"""
37
38	key2 = key2.replace("/", "/.")	12✔
39	key2 = KEY_MATCH2_PATTERN.sub(r"\g<1>[^\/]+\g<2>", key2, 0)	12✔
40
41	if key2 == "*":	12✔
42	key2 = "(.*)"	12✔
43
44	return regex_match(key1, "^" + key2 + "$")	12✔
45
46
47	def key_match2_func(*args):	12✔
48	name1 = args[0]	12✔
49	name2 = args[1]	12✔
50
51	return key_match2(name1, name2)	12✔
52
53
54	def key_match3(key1, key2):	12✔
55	"""determines determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
56	For example, "/foo/bar" matches "/foo/*", "/resource1" matches "/{resource}"
57	"""
58
59	key2 = key2.replace("/", "/.")	12✔
60	key2 = KEY_MATCH3_PATTERN.sub(r"\g<1>[^\/]+\g<2>", key2, 0)	12✔
61
62	return regex_match(key1, "^" + key2 + "$")	12✔
63
64
65	def key_match3_func(*args):	12✔
66	name1 = args[0]	12✔
67	name2 = args[1]	12✔
68
69	return key_match3(name1, name2)	12✔
70
71
72	def key_match4(key1: str, key2: str) -> bool:	12✔
73	"""
74	key_match4 determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
75	Besides what key_match3 does, key_match4 can also match repeated patterns:
76	"/parent/123/child/123" matches "/parent/{id}/child/{id}"
77	"/parent/123/child/456" does not match "/parent/{id}/child/{id}"
78	But key_match3 will match both.
79	"""
80	key2 = key2.replace("/", "/.")	12✔
81
82	tokens: [str] = []	12✔
83
84	def repl(matchobj):	12✔
85	tokens.append(matchobj.group(1))	12✔
86	return "([^/]+)"	12✔
87
88	key2 = KEY_MATCH4_PATTERN.sub(repl, key2)	12✔
89
90	regexp = re.compile("^" + key2 + "$")	12✔
91	matches = regexp.match(key1)	12✔
92
93	if matches is None:	12✔
94	return False	12✔
95	if len(tokens) != len(matches.groups()):	12✔
NEW 96	raise Exception("KeyMatch4: number of tokens is not equal to number of values")	×
97
98	tokens_matches = dict()	12✔
99
100	for i in range(len(tokens)):	12✔
101	token, match = tokens[i], matches.groups()[i]	12✔
102
103	if token not in tokens_matches.keys():	12✔
104	tokens_matches[token] = match	12✔
105	else:
106	if tokens_matches[token] != match:	12✔
107	return False	12✔
108	return True	12✔
109
110
111	def key_match4_func(*args) -> bool:	12✔
112	"""
113	key_match4_func is the wrapper for key_match4.
114	"""
115	name1 = args[0]	12✔
116	name2 = args[1]	12✔
117
118	return key_match4(name1, name2)	12✔
119
120
121	def regex_match(key1, key2):	12✔
122	"""determines whether key1 matches the pattern of key2 in regular expression."""
123
124	res = re.match(key2, key1)	12✔
125	if res:	12✔
126	return True	12✔
127	else:
128	return False	12✔
129
130
131	def regex_match_func(*args):	12✔
132	"""the wrapper for RegexMatch."""
133
134	name1 = args[0]	12✔
135	name2 = args[1]	12✔
136
137	return regex_match(name1, name2)	12✔
138
139
140	def glob_match(string, pattern):	12✔
141	"""determines whether string matches the pattern in glob expression."""
142	return pathlib.Path(string).globmatch(pattern)	12✔
143
144
145	def glob_match_func(*args):	12✔
146	"""the wrapper for globMatch."""
147
148	string = args[0]	12✔
149	pattern = args[1]	12✔
150
151	return glob_match(string, pattern)	12✔
152
153
154	def ip_match(ip1, ip2):	12✔
155	"""IPMatch determines whether IP address ip1 matches the pattern of IP address ip2, ip2 can be an IP address or a CIDR pattern.
156	For example, "192.168.2.123" matches "192.168.2.0/24"
157	"""
158	ip1 = ipaddress.ip_address(ip1)	12✔
159	try:	12✔
160	network = ipaddress.ip_network(ip2, strict=False)	12✔
161	return ip1 in network	12✔
162	except ValueError:	×
163	return ip1 == ip2	×
164
165
166	def ip_match_func(*args):	12✔
167	"""the wrapper for IPMatch."""
168
169	ip1 = args[0]	12✔
170	ip2 = args[1]	12✔
171
172	return ip_match(ip1, ip2)	12✔
173
174
175	def generate_g_function(rm):	12✔
176	"""the factory method of the g(_, _) function."""
177
178	def f(*args):	12✔
179	name1 = args[0]	12✔
180	name2 = args[1]	12✔
181
182	if not rm:	12✔
183	return name1 == name2	×
184	elif 2 == len(args):	12✔
185	return rm.has_link(name1, name2)	12✔
186	else:
187	domain = str(args[2])	12✔
188	return rm.has_link(name1, name2, domain)	12✔
189
190	return f	12✔

casbin / pycasbin / 1165765906

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous