2226623147

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/bb5a18ca794abd3f7c1765f0e62bcb52dafb4661">bb5a18ca7<a href="https://github.com/casbin/pycasbin/commit/bb5a18ca794abd3f7c1765f0e62bcb52dafb4661">&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/bb5a18ca794abd3f7c1765f0e62bcb52dafb4661&quot;&gt;bb5a18ca7&lt;/a&gt;&lt;a href=&quot;https://github.com/casbin/pycasbin/commit/bb5a18ca794abd3f7c1765f0e62bcb52dafb4661&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/casbin/pycasbin/commit/bb5a18ca794abd3f7c1765f0e62bcb52&lt;/a&gt;dafb4661">&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/d6b572cb3fa986210c7a487c091df0e460f9f976">d6b572cb3</a><a href="https://github.com/casbin/pycasbin/commit/bb5a18ca794abd3f7c1765f0e62bcb52dafb4661">&amp;quot;&amp;gt;d6b572cb3&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;d6b572cb3&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/casbin/pycasbin/commit/bb5a18ca794abd3f7c1765f0e62bcb52dafb4&lt;/a&gt;661&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

24 of 26 new or added lines in 1 file covered. (92.31%)

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

casbin / pycasbin / 2226623147

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