2226604096

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/309080df1b23234ea2208ad00689f14b15285b9a">309080df1<a href="https://github.com/casbin/pycasbin/commit/309080df1b23234ea2208ad00689f14b15285b9a">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/casbin/pycasbin/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/casbin/pycasbin/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/casbin/pycasbin/commit/309080df1b23234ea2208ad00689f14b15285b9a&quot;&gt;309080df1&lt;/a&gt;&lt;a href=&quot;https://github.com/casbin/pycasbin/commit/309080df1b23234ea2208ad00689f14b15285b9a&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/casbin/pycasbin/commit/309080df1b23234ea2208ad00689f14b&lt;/a&gt;15285b9a">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/casbin/pycasbin/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/casbin/pycasbin/commit/<a class="double-link" href="https://github.com/casbin/pycasbin/commit/e1f534da51c9f5bab541fdc3641cbd5cb82a52e5">e1f534da5</a><a href="https://github.com/casbin/pycasbin/commit/309080df1b23234ea2208ad00689f14b15285b9a">&amp;quot;&amp;gt;e1f534da5&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;e1f534da5&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/casbin/pycasbin/commit/309080df1b23234ea2208ad00689f14b15285&lt;/a&gt;b9a&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/casbin/pycasbin/commit/<a class="double-link" href="https://github.com/casbin/pycasbin/commit/f75702401">f75702401">f75702401</a>

Pull Request Pull Request #254: fix: different behavior of glob_match from other casbin

Run Details

23 of 25 new or added lines in 1 file covered. (92.0%)

1866 of 2182 relevant lines covered (85.52%)

10.26 hits per line

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

95.04

/casbin/util/builtin_operators.py

# Copyright 2021 The casbin Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import ipaddress
import re


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."""
    pattern_len = len(pattern)
    string_len = len(string)
    if pattern_len == 0:
        return string_len == 0
    pattern_index = 0
    string_index = 0
    while True:
        if pattern_index == pattern_len:
            return string_len == string_index
        c = pattern[pattern_index]
        pattern_index += 1
        if c == '*':
            while (pattern_index != pattern_len) and (c == '*'):
                c = pattern[pattern_index]
                pattern_index += 1
            if pattern_index == pattern_len:
                return string.find('/', string_index) == -1
            else:
                if c == '/':
                    string_index = string.find('/', string_index)
                    if string_index == -1:
                        return False
                    else:
                        string_index += 1
        else:
            if string_index == string_len:
                return False
            else:
                if c == string[string_index]:
                    string_index += 1
                else:
                    return False


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	# Copyright 2021 The casbin Authors. All Rights Reserved.
2	#
3	# Licensed under the Apache License, Version 2.0 (the "License");
4	# you may not use this file except in compliance with the License.
5	# You may obtain a copy of the License at
6	#
7	# http://www.apache.org/licenses/LICENSE-2.0
8	#
9	# Unless required by applicable law or agreed to in writing, software
10	# distributed under the License is distributed on an "AS IS" BASIS,
11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	# See the License for the specific language governing permissions and
13	# limitations under the License.
14
15	import ipaddress	12✔
16	import re	12✔
17
18
19	KEY_MATCH2_PATTERN = re.compile(r"(.?):[^\/]+(.?)")	12✔
20	KEY_MATCH3_PATTERN = re.compile(r"(.?){[^\/]+}(.?)")	12✔
21	KEY_MATCH4_PATTERN = re.compile(r"{([^/]+)}")	12✔
22
23
24	def key_match(key1, key2):	12✔
25	"""determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
26	For example, "/foo/bar" matches "/foo/*"
27	"""
28
29	i = key2.find("*")	12✔
30	if i == -1:	12✔
31	return key1 == key2	12✔
32
33	if len(key1) > i:	12✔
34	return key1[:i] == key2[:i]	12✔
35	return key1 == key2[:i]	12✔
36
37
38	def key_match_func(*args):	12✔
39	"""The wrapper for key_match."""
40	name1 = args[0]	12✔
41	name2 = args[1]	12✔
42
43	return key_match(name1, name2)	12✔
44
45
46	def key_match2(key1, key2):	12✔
47	"""determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
48	For example, "/foo/bar" matches "/foo/*", "/resource1" matches "/:resource"
49	"""
50
51	key2 = key2.replace("/", "/.")	12✔
52	key2 = KEY_MATCH2_PATTERN.sub(r"\g<1>[^\/]+\g<2>", key2, 0)	12✔
53
54	if key2 == "*":	12✔
55	key2 = "(.*)"	12✔
56
57	return regex_match(key1, "^" + key2 + "$")	12✔
58
59
60	def key_match2_func(*args):	12✔
61	name1 = args[0]	12✔
62	name2 = args[1]	12✔
63
64	return key_match2(name1, name2)	12✔
65
66
67	def key_match3(key1, key2):	12✔
68	"""determines determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
69	For example, "/foo/bar" matches "/foo/*", "/resource1" matches "/{resource}"
70	"""
71
72	key2 = key2.replace("/", "/.")	12✔
73	key2 = KEY_MATCH3_PATTERN.sub(r"\g<1>[^\/]+\g<2>", key2, 0)	12✔
74
75	return regex_match(key1, "^" + key2 + "$")	12✔
76
77
78	def key_match3_func(*args):	12✔
79	name1 = args[0]	12✔
80	name2 = args[1]	12✔
81
82	return key_match3(name1, name2)	12✔
83
84
85	def key_match4(key1: str, key2: str) -> bool:	12✔
86	"""
87	key_match4 determines whether key1 matches the pattern of key2 (similar to RESTful path), key2 can contain a *.
88	Besides what key_match3 does, key_match4 can also match repeated patterns:
89	"/parent/123/child/123" matches "/parent/{id}/child/{id}"
90	"/parent/123/child/456" does not match "/parent/{id}/child/{id}"
91	But key_match3 will match both.
92	"""
93	key2 = key2.replace("/", "/.")	12✔
94
95	tokens: [str] = []	12✔
96
97	def repl(matchobj):	12✔
98	tokens.append(matchobj.group(1))	12✔
99	return "([^/]+)"	12✔
100
101	key2 = KEY_MATCH4_PATTERN.sub(repl, key2)	12✔
102
103	regexp = re.compile("^" + key2 + "$")	12✔
104	matches = regexp.match(key1)	12✔
105
106	if matches is None:	12✔
107	return False	12✔
108	if len(tokens) != len(matches.groups()):	12✔
109	raise Exception("KeyMatch4: number of tokens is not equal to number of values")	×
110
111	tokens_matches = dict()	12✔
112
113	for i in range(len(tokens)):	12✔
114	token, match = tokens[i], matches.groups()[i]	12✔
115
116	if token not in tokens_matches.keys():	12✔
117	tokens_matches[token] = match	12✔
118	else:
119	if tokens_matches[token] != match:	12✔
120	return False	12✔
121	return True	12✔
122
123
124	def key_match4_func(*args) -> bool:	12✔
125	"""
126	key_match4_func is the wrapper for key_match4.
127	"""
128	name1 = args[0]	12✔
129	name2 = args[1]	12✔
130
131	return key_match4(name1, name2)	12✔
132
133
134	def regex_match(key1, key2):	12✔
135	"""determines whether key1 matches the pattern of key2 in regular expression."""
136
137	res = re.match(key2, key1)	12✔
138	if res:	12✔
139	return True	12✔
140	else:
141	return False	12✔
142
143
144	def regex_match_func(*args):	12✔
145	"""the wrapper for RegexMatch."""
146
147	name1 = args[0]	12✔
148	name2 = args[1]	12✔
149
150	return regex_match(name1, name2)	12✔
151
152
153	def glob_match(string, pattern):	12✔
154	"""determines whether string matches the pattern in glob expression."""
155	pattern_len = len(pattern)	12✔
156	string_len = len(string)	12✔
157	if pattern_len == 0:	12✔
NEW 158	return string_len == 0	×
159	pattern_index = 0	12✔
160	string_index = 0	12✔
161	while True:	6✔
162	if pattern_index == pattern_len:	12✔
163	return string_len == string_index	12✔
164	c = pattern[pattern_index]	12✔
165	pattern_index += 1	12✔
166	if c == '*':	12✔
167	while (pattern_index != pattern_len) and (c == '*'):	12✔
168	c = pattern[pattern_index]	12✔
169	pattern_index += 1	12✔
170	if pattern_index == pattern_len:	12✔
171	return string.find('/', string_index) == -1	12✔
172	else:
173	if c == '/':	12✔
174	string_index = string.find('/', string_index)	12✔
175	if string_index == -1:	12✔
NEW 176	return False	×
177	else:
178	string_index += 1	12✔
179	else:
180	if string_index == string_len:	12✔
181	return False	12✔
182	else:
183	if c == string[string_index]:	12✔
184	string_index += 1	12✔
185	else:
186	return False	12✔
187
188
189	def glob_match_func(*args):	12✔
190	"""the wrapper for globMatch."""
191
192	string = args[0]	12✔
193	pattern = args[1]	12✔
194
195	return glob_match(string, pattern)	12✔
196
197
198	def ip_match(ip1, ip2):	12✔
199	"""IPMatch determines whether IP address ip1 matches the pattern of IP address ip2, ip2 can be an IP address or a CIDR pattern.
200	For example, "192.168.2.123" matches "192.168.2.0/24"
201	"""
202	ip1 = ipaddress.ip_address(ip1)	12✔
203	try:	12✔
204	network = ipaddress.ip_network(ip2, strict=False)	12✔
205	return ip1 in network	12✔
206	except ValueError:	×
207	return ip1 == ip2	×
208
209
210	def ip_match_func(*args):	12✔
211	"""the wrapper for IPMatch."""
212
213	ip1 = args[0]	12✔
214	ip2 = args[1]	12✔
215
216	return ip_match(ip1, ip2)	12✔
217
218
219	def generate_g_function(rm):	12✔
220	"""the factory method of the g(_, _) function."""
221
222	def f(*args):	12✔
223	name1 = args[0]	12✔
224	name2 = args[1]	12✔
225
226	if not rm:	12✔
227	return name1 == name2	×
228	elif 2 == len(args):	12✔
229	return rm.has_link(name1, name2)	12✔
230	else:
231	domain = str(args[2])	12✔
232	return rm.has_link(name1, name2, domain)	12✔
233
234	return f	12✔

casbin / pycasbin / 2226604096

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