1#!/usr/bin/env python
2
3"""Manage site and releases.
4
5Usage:
6  manage.py release [<branch>]
7  manage.py site
8
9For the release command $FMT_TOKEN should contain a GitHub personal access token
10obtained from https://github.com/settings/tokens.
11"""
12
13from __future__ import print_function
14import datetime, docopt, errno, fileinput, json, os
15import re, requests, shutil, sys, tempfile
16from contextlib import contextmanager
17from distutils.version import LooseVersion
18from subprocess import check_call
19
20
21class Git:
22    def __init__(self, dir):
23        self.dir = dir
24
25    def call(self, method, args, **kwargs):
26        return check_call(['git', method] + list(args), **kwargs)
27
28    def add(self, *args):
29        return self.call('add', args, cwd=self.dir)
30
31    def checkout(self, *args):
32        return self.call('checkout', args, cwd=self.dir)
33
34    def clean(self, *args):
35        return self.call('clean', args, cwd=self.dir)
36
37    def clone(self, *args):
38        return self.call('clone', list(args) + [self.dir])
39
40    def commit(self, *args):
41        return self.call('commit', args, cwd=self.dir)
42
43    def pull(self, *args):
44        return self.call('pull', args, cwd=self.dir)
45
46    def push(self, *args):
47        return self.call('push', args, cwd=self.dir)
48
49    def reset(self, *args):
50        return self.call('reset', args, cwd=self.dir)
51
52    def update(self, *args):
53        clone = not os.path.exists(self.dir)
54        if clone:
55            self.clone(*args)
56        return clone
57
58
59def clean_checkout(repo, branch):
60    repo.clean('-f', '-d')
61    repo.reset('--hard')
62    repo.checkout(branch)
63
64
65class Runner:
66    def __init__(self, cwd):
67        self.cwd = cwd
68
69    def __call__(self, *args, **kwargs):
70        kwargs['cwd'] = kwargs.get('cwd', self.cwd)
71        check_call(args, **kwargs)
72
73
74def create_build_env():
75    """Create a build environment."""
76    class Env:
77        pass
78    env = Env()
79
80    # Import the documentation build module.
81    env.fmt_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
82    sys.path.insert(0, os.path.join(env.fmt_dir, 'doc'))
83    import build
84
85    env.build_dir = 'build'
86    env.versions = build.versions
87
88    # Virtualenv and repos are cached to speed up builds.
89    build.create_build_env(os.path.join(env.build_dir, 'virtualenv'))
90
91    env.fmt_repo = Git(os.path.join(env.build_dir, 'fmt'))
92    return env
93
94
95@contextmanager
96def rewrite(filename):
97    class Buffer:
98        pass
99    buffer = Buffer()
100    if not os.path.exists(filename):
101        buffer.data = ''
102        yield buffer
103        return
104    with open(filename) as f:
105        buffer.data = f.read()
106    yield buffer
107    with open(filename, 'w') as f:
108        f.write(buffer.data)
109
110
111fmt_repo_url = 'git@github.com:fmtlib/fmt'
112
113
114def update_site(env):
115    env.fmt_repo.update(fmt_repo_url)
116
117    doc_repo = Git(os.path.join(env.build_dir, 'fmtlib.github.io'))
118    doc_repo.update('git@github.com:fmtlib/fmtlib.github.io')
119
120    for version in env.versions:
121        clean_checkout(env.fmt_repo, version)
122        target_doc_dir = os.path.join(env.fmt_repo.dir, 'doc')
123        # Remove the old theme.
124        for entry in os.listdir(target_doc_dir):
125            path = os.path.join(target_doc_dir, entry)
126            if os.path.isdir(path):
127                shutil.rmtree(path)
128        # Copy the new theme.
129        for entry in ['_static', '_templates', 'basic-bootstrap', 'bootstrap',
130                      'conf.py', 'fmt.less']:
131            src = os.path.join(env.fmt_dir, 'doc', entry)
132            dst = os.path.join(target_doc_dir, entry)
133            copy = shutil.copytree if os.path.isdir(src) else shutil.copyfile
134            copy(src, dst)
135        # Rename index to contents.
136        contents = os.path.join(target_doc_dir, 'contents.rst')
137        if not os.path.exists(contents):
138            os.rename(os.path.join(target_doc_dir, 'index.rst'), contents)
139        # Fix issues in reference.rst/api.rst.
140        for filename in ['reference.rst', 'api.rst', 'index.rst']:
141            pattern = re.compile('doxygenfunction.. (bin|oct|hexu|hex)$', re.M)
142            with rewrite(os.path.join(target_doc_dir, filename)) as b:
143                b.data = b.data.replace('std::ostream &', 'std::ostream&')
144                b.data = re.sub(pattern, r'doxygenfunction:: \1(int)', b.data)
145                b.data = b.data.replace('std::FILE*', 'std::FILE *')
146                b.data = b.data.replace('unsigned int', 'unsigned')
147                b.data = b.data.replace('operator""_', 'operator"" _')
148                b.data = b.data.replace(', size_t', ', std::size_t')
149                b.data = b.data.replace('aa long', 'a long')
150        # Fix a broken link in index.rst.
151        index = os.path.join(target_doc_dir, 'index.rst')
152        with rewrite(index) as b:
153            b.data = b.data.replace(
154                'doc/latest/index.html#format-string-syntax', 'syntax.html')
155        # Build the docs.
156        html_dir = os.path.join(env.build_dir, 'html')
157        if os.path.exists(html_dir):
158            shutil.rmtree(html_dir)
159        include_dir = env.fmt_repo.dir
160        if LooseVersion(version) >= LooseVersion('5.0.0'):
161            include_dir = os.path.join(include_dir, 'include', 'fmt')
162        elif LooseVersion(version) >= LooseVersion('3.0.0'):
163            include_dir = os.path.join(include_dir, 'fmt')
164        import build
165        build.build_docs(version, doc_dir=target_doc_dir,
166                         include_dir=include_dir, work_dir=env.build_dir)
167        shutil.rmtree(os.path.join(html_dir, '.doctrees'))
168        # Create symlinks for older versions.
169        for link, target in {'index': 'contents', 'api': 'reference'}.items():
170            link = os.path.join(html_dir, link) + '.html'
171            target += '.html'
172            if os.path.exists(os.path.join(html_dir, target)) and \
173               not os.path.exists(link):
174                os.symlink(target, link)
175        # Copy docs to the website.
176        version_doc_dir = os.path.join(doc_repo.dir, version)
177        try:
178            shutil.rmtree(version_doc_dir)
179        except OSError as e:
180            if e.errno != errno.ENOENT:
181                raise
182        shutil.move(html_dir, version_doc_dir)
183
184
185def release(args):
186    env = create_build_env()
187    fmt_repo = env.fmt_repo
188
189    branch = args.get('<branch>')
190    if branch is None:
191        branch = 'master'
192    if not fmt_repo.update('-b', branch, fmt_repo_url):
193        clean_checkout(fmt_repo, branch)
194
195    # Convert changelog from RST to GitHub-flavored Markdown and get the
196    # version.
197    changelog = 'ChangeLog.rst'
198    changelog_path = os.path.join(fmt_repo.dir, changelog)
199    import rst2md
200    changes, version = rst2md.convert(changelog_path)
201    cmakelists = 'CMakeLists.txt'
202    for line in fileinput.input(os.path.join(fmt_repo.dir, cmakelists),
203                                inplace=True):
204        prefix = 'set(FMT_VERSION '
205        if line.startswith(prefix):
206            line = prefix + version + ')\n'
207        sys.stdout.write(line)
208
209    # Update the version in the changelog.
210    title_len = 0
211    for line in fileinput.input(changelog_path, inplace=True):
212        if line.decode('utf-8').startswith(version + ' - TBD'):
213            line = version + ' - ' + datetime.date.today().isoformat()
214            title_len = len(line)
215            line += '\n'
216        elif title_len:
217            line = '-' * title_len + '\n'
218            title_len = 0
219        sys.stdout.write(line)
220
221    # Add the version to the build script.
222    script = os.path.join('doc', 'build.py')
223    script_path = os.path.join(fmt_repo.dir, script)
224    for line in fileinput.input(script_path, inplace=True):
225      m = re.match(r'( *versions = )\[(.+)\]', line)
226      if m:
227        line = '{}[{}, \'{}\']\n'.format(m.group(1), m.group(2), version)
228      sys.stdout.write(line)
229
230    fmt_repo.checkout('-B', 'release')
231    fmt_repo.add(changelog, cmakelists, script)
232    fmt_repo.commit('-m', 'Update version')
233
234    # Build the docs and package.
235    run = Runner(fmt_repo.dir)
236    run('cmake', '.')
237    run('make', 'doc', 'package_source')
238    update_site(env)
239
240    # Create a release on GitHub.
241    fmt_repo.push('origin', 'release')
242    params = {'access_token': os.getenv('FMT_TOKEN')}
243    r = requests.post('https://api.github.com/repos/fmtlib/fmt/releases',
244                      params=params,
245                      data=json.dumps({'tag_name': version,
246                                       'target_commitish': 'release',
247                                       'body': changes, 'draft': True}))
248    if r.status_code != 201:
249        raise Exception('Failed to create a release ' + str(r))
250    id = r.json()['id']
251    uploads_url = 'https://uploads.github.com/repos/fmtlib/fmt/releases'
252    package = 'fmt-{}.zip'.format(version)
253    r = requests.post(
254        '{}/{}/assets?name={}'.format(uploads_url, id, package),
255        headers={'Content-Type': 'application/zip'},
256        params=params, data=open('build/fmt/' + package, 'rb'))
257    if r.status_code != 201:
258        raise Exception('Failed to upload an asset ' + str(r))
259
260
261if __name__ == '__main__':
262    args = docopt.docopt(__doc__)
263    if args.get('release'):
264        release(args)
265    elif args.get('site'):
266        update_site(create_build_env())
267