2230439639

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/ad86cd165676b326705c58e7afba13ac20bb15e0">ad86cd165">&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/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/casbin/pycasbin/commit/ad86cd165676b326705c58e7afba13ac20bb15e0">ad86cd165</a><a href="https://github.com/casbin/pycasbin/commit/ad86cd165676b326705c58e7afba13ac20bb15e0">&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/&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/&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/&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/ad86cd165676b326705c58e7afba13ac20bb15e0&quot;&gt;ad86cd165&lt;/a&gt;&lt;a href=&quot;https://github.com/casbin/pycasbin/commit/ad86cd165676b326705c58e7afba13ac20bb15e0&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&am... (continued)

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

Run Details

30 of 32 new or added lines in 1 file covered. (93.75%)

1872 of 2188 relevant lines covered (85.56%)

10.27 hits per line

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

95.28

/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
            # General case, use recursion.
            while string_index != string_len:
                if glob_match(string[string_index:], pattern[pattern_index:]):
                    return True
                if string[string_index] == "/":
                    break
                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	# General case, use recursion.
179	while string_index != string_len:	12✔
180	if glob_match(string[string_index:], pattern[pattern_index:]):	12✔
181	return True	12✔
182	if string[string_index] == "/":	12✔
183	break	12✔
184	string_index += 1	12✔
185	else:
186	if string_index == string_len:	12✔
187	return False	12✔
188	else:
189	if c == string[string_index]:	12✔
190	string_index += 1	12✔
191	else:
192	return False	12✔
193
194
195	def glob_match_func(*args):	12✔
196	"""the wrapper for globMatch."""
197
198	string = args[0]	12✔
199	pattern = args[1]	12✔
200
201	return glob_match(string, pattern)	12✔
202
203
204	def ip_match(ip1, ip2):	12✔
205	"""IPMatch determines whether IP address ip1 matches the pattern of IP address ip2, ip2 can be an IP address or a CIDR pattern.
206	For example, "192.168.2.123" matches "192.168.2.0/24"
207	"""
208	ip1 = ipaddress.ip_address(ip1)	12✔
209	try:	12✔
210	network = ipaddress.ip_network(ip2, strict=False)	12✔
211	return ip1 in network	12✔
212	except ValueError:	×
213	return ip1 == ip2	×
214
215
216	def ip_match_func(*args):	12✔
217	"""the wrapper for IPMatch."""
218
219	ip1 = args[0]	12✔
220	ip2 = args[1]	12✔
221
222	return ip_match(ip1, ip2)	12✔
223
224
225	def generate_g_function(rm):	12✔
226	"""the factory method of the g(_, _) function."""
227
228	def f(*args):	12✔
229	name1 = args[0]	12✔
230	name2 = args[1]	12✔
231
232	if not rm:	12✔
233	return name1 == name2	×
234	elif 2 == len(args):	12✔
235	return rm.has_link(name1, name2)	12✔
236	else:
237	domain = str(args[2])	12✔
238	return rm.has_link(name1, name2, domain)	12✔
239
240	return f	12✔

casbin / pycasbin / 2230439639

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