forked from bollenn/robotframework
-
Notifications
You must be signed in to change notification settings - Fork 0
/
tasks.py
278 lines (217 loc) · 9.9 KB
/
tasks.py
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
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
"""Tasks to help Robot Framework packaging and other development.
Executed by Invoke <http://pyinvoke.org>. Install it with `pip install invoke`
and run `invoke --help` and `invoke --list` for details how to execute tasks.
See BUILD.rst for packaging and releasing instructions.
"""
from pathlib import Path
from urllib.request import urlretrieve
import os
import shutil
import sys
import tarfile
import tempfile
import zipfile
assert Path.cwd().resolve() == Path(__file__).resolve().parent
sys.path.insert(0, 'src')
from invoke import Exit, task
from rellu import initialize_labels, ReleaseNotesGenerator, Version
from rellu.tasks import clean
from robot.libdoc import libdoc
REPOSITORY = 'robotframework/robotframework'
VERSION_PATH = Path('src/robot/version.py')
VERSION_PATTERN = "VERSION = '(.*)'"
POM_PATH = Path('pom.xml')
POM_VERSION_PATTERN = '<version>(.*)</version>'
RELEASE_NOTES_PATH = Path('doc/releasenotes/rf-{version}.rst')
RELEASE_NOTES_TITLE = 'Robot Framework {version}'
RELEASE_NOTES_INTRO = '''
`Robot Framework`_ {version} is a new release with **UPDATE** enhancements
and bug fixes. **MORE intro stuff...**
**REMOVE reference to tracker if release notes contain all issues.**
All issues targeted for Robot Framework {version.milestone} can be found
from the `issue tracker milestone`_.
Questions and comments related to the release can be sent to the
`robotframework-users`_ mailing list or to `Robot Framework Slack`_,
and possible bugs submitted to the `issue tracker`_.
**REMOVE ``--pre`` from the next command with final releases.**
If you have pip_ installed, just run
::
pip install --pre --upgrade robotframework
to install the latest available release or use
::
pip install robotframework=={version}
to install exactly this version. Alternatively you can download the source
distribution from PyPI_ and install it manually. For more details and other
installation approaches, see the `installation instructions`_.
Robot Framework {version} was released on {date}.
.. _Robot Framework: http://robotframework.org
.. _Robot Framework Foundation: http://robotframework.org/foundation
.. _pip: http://pip-installer.org
.. _PyPI: https://pypi.python.org/pypi/robotframework
.. _issue tracker milestone: https://github.com/robotframework/robotframework/issues?q=milestone%3A{version.milestone}
.. _issue tracker: https://github.com/robotframework/robotframework/issues
.. _robotframework-users: http://groups.google.com/group/robotframework-users
.. _Robot Framework Slack: https://robotframework-slack-invite.herokuapp.com
.. _installation instructions: ../../INSTALL.rst
'''
@task
def set_version(ctx, version):
"""Set project version in `src/robot/version.py`` file.
Args:
version: Project version to set or ``dev`` to set development version.
Following PEP-440 compatible version numbers are supported:
- Final version like 3.0 or 3.1.2.
- Alpha, beta or release candidate with ``a``, ``b`` or ``rc`` postfix,
respectively, and an incremented number like 3.0a1 or 3.0.1rc1.
- Development version with ``.dev`` postix and an incremented number like
3.0.dev1 or 3.1a1.dev2.
When the given version is ``dev``, the existing version number is updated
to the next suitable development version. For example, 3.0 -> 3.0.1.dev1,
3.1.1 -> 3.1.2.dev1, 3.2a1 -> 3.2a2.dev1, 3.2.dev1 -> 3.2.dev2.
"""
version = Version(version, VERSION_PATH, VERSION_PATTERN)
version.write()
pom = Version(str(version), POM_PATH, POM_VERSION_PATTERN)
pom.write()
print(version)
@task
def print_version(ctx):
"""Print the current project version."""
print(Version(path=VERSION_PATH, pattern=VERSION_PATTERN))
@task
def library_docs(ctx, name):
"""Generate standard library documentation.
Args:
name: Name of the library or ``all`` to generate docs for all libs.
Name is case-insensitive and can be shortened as long as it
is a unique prefix. For example, ``b`` is equivalent to
``BuiltIn`` and ``di`` equivalent to ``Dialogs``.
"""
libraries = ['BuiltIn', 'Collections', 'DateTime', 'Dialogs',
'OperatingSystem', 'Process', 'Screenshot', 'String',
'Telnet', 'XML']
name = name.lower()
if name != 'all':
libraries = [lib for lib in libraries if lib.lower().startswith(name)]
if len(libraries) != 1:
raise Exit(f"'{name}' is not a unique library prefix.")
for lib in libraries:
libdoc(lib, str(Path(f'doc/libraries/{lib}.html')))
@task
def release_notes(ctx, version=None, username=None, password=None, write=False):
"""Generate release notes based on issues in the issue tracker.
Args:
version: Generate release notes for this version. If not given,
generated them for the current version.
username: GitHub username.
password: GitHub password.
write: When set to True, write release notes to a file overwriting
possible existing file. Otherwise just print them to the
terminal.
Username and password can also be specified using ``GITHUB_USERNAME`` and
``GITHUB_PASSWORD`` environment variable, respectively. If they aren't
specified at all, communication with GitHub is anonymous and typically
pretty slow.
"""
version = Version(version, VERSION_PATH, VERSION_PATTERN)
file = RELEASE_NOTES_PATH if write else sys.stdout
generator = ReleaseNotesGenerator(REPOSITORY, RELEASE_NOTES_TITLE,
RELEASE_NOTES_INTRO)
generator.generate(version, username, password, file)
@task
def init_labels(ctx, username=None, password=None):
"""Initialize project by setting labels in the issue tracker.
Args:
username: GitHub username.
password: GitHub password.
Username and password can also be specified using ``GITHUB_USERNAME`` and
``GITHUB_PASSWORD`` environment variable, respectively.
Should only be executed once when taking ``rellu`` tooling to use or
when labels it uses have changed.
"""
initialize_labels(REPOSITORY, username, password)
@task
def jar(ctx, jython_version='2.7.0', pyyaml_version='5.1', remove_dist=False):
"""Create JAR distribution.
Downloads Jython JAR and PyYAML if needed.
Args:
jython_version: Jython version to use as a base. Must match version in
`jython-standalone-<version>.jar` found from Maven central.
pyyaml_version: Version of PyYAML that will be included in the
standalone jar. The version must be available from PyPI.
remove_dist: Control is 'dist' directory initially removed or not.
"""
clean(ctx, remove_dist, create_dirs=True)
jython_jar = get_jython_jar(jython_version)
print(f"Using '{jython_jar}'.")
compile_java_files(ctx, jython_jar)
unzip_jar(jython_jar)
copy_robot_files()
pyaml_archive = get_pyyaml(pyyaml_version)
extract_and_copy_pyyaml_files(pyyaml_version, pyaml_archive)
compile_python_files(ctx, jython_jar)
version = Version(path=VERSION_PATH, pattern=VERSION_PATTERN)
create_robot_jar(ctx, str(version))
def get_jython_jar(version):
filename = 'jython-standalone-{0}.jar'.format(version)
url = (f'http://search.maven.org/remotecontent?filepath=org/python/'
f'jython-standalone/{version}/{filename}')
return get_extlib_file(filename, url)
def get_pyyaml(version):
filename = f'PyYAML-{version}.tar.gz'
url = f'https://pypi.python.org/packages/source/P/PyYAML/{filename}'
return get_extlib_file(filename, url)
def get_extlib_file(filename, url):
lib = Path('ext-lib')
path = Path(lib, filename)
if path.exists():
return path
print(f"'{filename}' not found, downloading it from '{url}'.")
lib.mkdir(exist_ok=True)
urlretrieve(url, path)
return path
def extract_and_copy_pyyaml_files(version, filename, build_dir='build'):
extracted = Path(tempfile.gettempdir(), 'pyyaml-for-robot')
if extracted.is_dir():
shutil.rmtree(str(extracted))
print(f"Extracting '{filename}' to '{extracted}'.")
with tarfile.open(filename) as t:
t.extractall(extracted)
source = Path(extracted, f'PyYAML-{version}', 'lib', 'yaml')
target = Path(build_dir, 'Lib', 'yaml')
shutil.copytree(str(source), str(target),
ignore=shutil.ignore_patterns('*.pyc'))
def compile_java_files(ctx, jython_jar, build_dir='build'):
root = Path('src/java/org/robotframework')
files = [str(path) for path in root.iterdir() if path.suffix == '.java']
print(f'Compiling {len(files)} Java files.')
ctx.run(f"javac -d {build_dir} -target 1.7 -source 1.7 -cp {jython_jar} "
f"{' '.join(files)}")
def unzip_jar(path, target='build'):
zipfile.ZipFile(path).extractall(target)
def copy_robot_files(build_dir='build'):
source = Path('src', 'robot')
target = Path(build_dir, 'Lib', 'robot')
shutil.copytree(str(source), str(target),
ignore=shutil.ignore_patterns('*.pyc'))
shutil.rmtree(str(Path(target, 'htmldata', 'testdata')))
def compile_python_files(ctx, jython_jar, build_dir='build'):
ctx.run(f"java -jar {jython_jar} -m compileall -x '.*3.py' {build_dir}")
# Jython will not work without its py-files, but robot will
for directory, _, files in os.walk(str(Path(build_dir, 'Lib', 'robot'))):
for name in files:
if name.endswith('.py'):
Path(directory, name).unlink()
def create_robot_jar(ctx, version, source='build'):
write_manifest(version, source)
target = Path(f'dist/robotframework-{version}.jar')
ctx.run(f'jar cvfM {target} -C {source} .')
print(f"Created '{target}'.")
def write_manifest(version, build_dir='build'):
with open(Path(build_dir, 'META-INF', 'MANIFEST.MF'), 'w') as mf:
mf.write(f'''\
Manifest-Version: 1.0
Main-Class: org.robotframework.RobotFramework
Specification-Version: 2
Implementation-Version: {version}
''')