1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
# Copyright Cartopy Contributors
#
# This file is part of Cartopy and is released under the LGPL license.
# See COPYING and COPYING.LESSER in the root of the repository for full
# licensing details.
from __future__ import (absolute_import, division, print_function)
from datetime import datetime
from fnmatch import fnmatch
import io
from itertools import chain
import os
import re
import subprocess
import pytest
import cartopy
LICENSE_TEMPLATE = """
# (C) British Crown Copyright {YEARS}, Met Office
#
# This file is part of cartopy.
#
# cartopy is free software: you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# cartopy is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with cartopy. If not, see <https://www.gnu.org/licenses/>.""".strip()
LICENSE_RE_PATTERN = re.escape(LICENSE_TEMPLATE).replace(r'\{YEARS\}', '(.*?)')
# Add shebang possibility or C comment starter to the LICENSE_RE_PATTERN
SHEBANG_PATTERN = r'((\#\!.*|\/\*)\n)?'
LICENSE_RE = re.compile(SHEBANG_PATTERN + LICENSE_RE_PATTERN, re.MULTILINE)
LICENSE_TEMPLATE_v2 = """
# Copyright Cartopy Contributors
#
# This file is part of Cartopy and is released under the LGPL license.
# See COPYING and COPYING.LESSER in the root of the repository for full
# licensing details.
""".strip()
LICENSE_RE_PATTERN_v2 = re.escape(LICENSE_TEMPLATE_v2)
LICENSE_RE_v2 = re.compile(SHEBANG_PATTERN + LICENSE_RE_PATTERN_v2,
re.MULTILINE)
# Guess cartopy repo directory of cartopy - realpath is used to mitigate
# against Python finding the cartopy package via a symlink.
CARTOPY_DIR = os.path.realpath(os.path.dirname(cartopy.__file__))
REPO_DIR = os.getenv('CARTOPY_GIT_DIR',
os.path.dirname(os.path.dirname(CARTOPY_DIR)))
class TestLicenseHeaders(object):
@staticmethod
def years_of_license_in_file(content, fname):
"""
Using :data:`LICENSE_RE` look for the years defined in the license
header of the given file handle.
If the license cannot be found in the given content, None will be
returned, else a tuple of (start_year, end_year) will be returned.
"""
license_matches = LICENSE_RE.match(content)
if not license_matches:
# no license found in file.
return None
years = license_matches.groups()[-1]
if len(years) == 4:
start_year = end_year = int(years)
elif len(years) == 11:
start_year, end_year = int(years[:4]), int(years[7:])
else:
raise ValueError("Unexpected year(s) string in {}'s copyright "
"notice: {!r}".format(fname, years))
return (start_year, end_year)
@staticmethod
def last_change_by_fname():
"""
Return a dictionary of all the files under git which maps to
the datetime of their last modification in the git history.
.. note::
This function raises a ValueError if the repo root does
not have a ".git" folder. If git is not installed on the system,
or cannot be found by subprocess, an IOError may also be raised.
"""
# Check the ".git" folder exists at the repo dir.
if not os.path.isdir(os.path.join(REPO_DIR, '.git')):
raise ValueError('{} is not a git repository.'.format(REPO_DIR))
# Call "git whatchanged" to get the details of all the files and when
# they were last changed.
output = subprocess.check_output(['git', 'ls-tree', '-z', '-r',
'--name-only', 'HEAD'],
cwd=REPO_DIR)
output = output.rstrip(b'\0').split(b'\0')
res = {}
for fname in output:
fname = fname.decode()
dt = subprocess.check_output(['git', 'log', '-1', '--pretty=%ct',
'--', fname],
cwd=REPO_DIR)
dt = datetime.fromtimestamp(int(dt))
res[fname] = dt
return res
def test_license_headers(self):
exclude_patterns = ('build/*',
'dist/*',
'docs/build/*',
'docs/source/examples/*.py',
'docs/source/sphinxext/*.py',
'lib/cartopy/examples/*.py',
'lib/cartopy/_version.py',
'versioneer.py',
)
try:
last_change_by_fname = self.last_change_by_fname()
except ValueError as e:
# Caught the case where this is not a git repo.
return pytest.skip('cartopy installation did not look like a git '
'repo: ' + str(e))
failed = False
for fname, last_change in sorted(last_change_by_fname.items()):
full_fname = os.path.join(REPO_DIR, fname)
root, ext = os.path.splitext(full_fname)
if ext in ('.py', '.pyx', '.c', '.cpp', '.h') and \
os.path.isfile(full_fname) and \
not any(fnmatch(fname, pat) for pat in exclude_patterns):
is_empty = os.path.getsize(full_fname) == 0
with io.open(full_fname, encoding='utf-8') as fh:
content = fh.read()
is_yearless_license = bool(LICENSE_RE_v2.match(content))
years = TestLicenseHeaders.years_of_license_in_file(
content, full_fname)
if is_empty:
# Allow completely empty files (e.g. ``__init__.py``)
pass
elif is_yearless_license:
# Allow new style license (v2).
pass
# What is left is the old-style (pre 2019) header.
elif years is None:
print('The file {} has no valid header license and '
'has not been excluded from the license header '
'test.'.format(fname))
failed = True
elif last_change.year > years[1]:
print('The file header at {} is out of date. The last'
' commit was in {}, but the copyright states it'
' was {}.'.format(fname, last_change.year,
years[1]))
failed = True
if failed:
raise ValueError('There were license header failures. See stdout.')
class TestFutureImports(object):
excluded = (
'*/cartopy/examples/*.py',
'*/docs/source/examples/*.py',
'*/cartopy/_crs.py', # A file created by setuptools for so loading.
'*/cartopy/trace.py', # Ditto.
'*/cartopy/geodesic/_geodesic.py',
'*/cartopy/_version.py',
)
future_imports_pattern = re.compile(
r"^from __future__ import \(absolute_import,\s*division,\s*"
r"print_function(,\s*unicode_literals)?\)$",
flags=re.MULTILINE)
def test_future_imports(self):
# Tests that every single Python file includes the appropriate
# __future__ import to enforce consistent behaviour.
check_paths = [CARTOPY_DIR]
failed = False
for dirpath, _, files in chain.from_iterable(os.walk(path)
for path in check_paths):
for fname in files:
full_fname = os.path.join(dirpath, fname)
if not full_fname.endswith('.py'):
continue
if not os.path.isfile(full_fname):
continue
if any(fnmatch(full_fname, pat) for pat in self.excluded):
continue
is_empty = os.path.getsize(full_fname) == 0
with io.open(full_fname, "r", encoding='utf-8') as fh:
content = fh.read()
has_future_import = re.search(
self.future_imports_pattern, content) is not None
if is_empty:
pass
elif not has_future_import:
print('The file {} has no valid __future__ imports '
'and has not been excluded from the imports '
'test.'.format(full_fname))
failed = True
if failed:
raise ValueError('There were __future__ import check failures. '
'See stdout.')
|
