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(
149                    'format_to_n(OutputIt, size_t, string_view, Args&&',
150                    'format_to_n(OutputIt, size_t, const S&, const Args&')
151                b.data = b.data.replace(
152                    'format_to_n(OutputIt, std::size_t, string_view, Args&&',
153                    'format_to_n(OutputIt, std::size_t, const S&, const Args&')
154                if version == ('3.0.2'):
155                    b.data = b.data.replace(
156                        'fprintf(std::ostream&', 'fprintf(std::ostream &')
157                if version == ('5.3.0'):
158                    b.data = b.data.replace(
159                        'format_to(OutputIt, const S&, const Args&...)',
160                        'format_to(OutputIt, const S &, const Args &...)')
161                if version.startswith('5.') or version.startswith('6.'):
162                    b.data = b.data.replace(', size_t', ', std::size_t')
163                if version.startswith('7.'):
164                    b.data = b.data.replace(', std::size_t', ', size_t')
165                    b.data = b.data.replace('join(It, It', 'join(It, Sentinel')
166                b.data = b.data.replace('aa long', 'a long')
167                b.data = b.data.replace('serveral', 'several')
168                if version.startswith('6.2.'):
169                    b.data = b.data.replace(
170                        'vformat(const S&, basic_format_args<' +
171                        'buffer_context<Char>>)',
172                        'vformat(const S&, basic_format_args<' +
173                        'buffer_context<type_identity_t<Char>>>)')
174        # Fix a broken link in index.rst.
175        index = os.path.join(target_doc_dir, 'index.rst')
176        with rewrite(index) as b:
177            b.data = b.data.replace(
178                'doc/latest/index.html#format-string-syntax', 'syntax.html')
179        # Build the docs.
180        html_dir = os.path.join(env.build_dir, 'html')
181        if os.path.exists(html_dir):
182            shutil.rmtree(html_dir)
183        include_dir = env.fmt_repo.dir
184        if LooseVersion(version) >= LooseVersion('5.0.0'):
185            include_dir = os.path.join(include_dir, 'include', 'fmt')
186        elif LooseVersion(version) >= LooseVersion('3.0.0'):
187            include_dir = os.path.join(include_dir, 'fmt')
188        import build
189        build.build_docs(version, doc_dir=target_doc_dir,
190                         include_dir=include_dir, work_dir=env.build_dir)
191        shutil.rmtree(os.path.join(html_dir, '.doctrees'))
192        # Create symlinks for older versions.
193        for link, target in {'index': 'contents', 'api': 'reference'}.items():
194            link = os.path.join(html_dir, link) + '.html'
195            target += '.html'
196            if os.path.exists(os.path.join(html_dir, target)) and \
197               not os.path.exists(link):
198                os.symlink(target, link)
199        # Copy docs to the website.
200        version_doc_dir = os.path.join(doc_repo.dir, version)
201        try:
202            shutil.rmtree(version_doc_dir)
203        except OSError as e:
204            if e.errno != errno.ENOENT:
205                raise
206        shutil.move(html_dir, version_doc_dir)
207
208
209def release(args):
210    env = create_build_env()
211    fmt_repo = env.fmt_repo
212
213    branch = args.get('<branch>')
214    if branch is None:
215        branch = 'master'
216    if not fmt_repo.update('-b', branch, fmt_repo_url):
217        clean_checkout(fmt_repo, branch)
218
219    # Convert changelog from RST to GitHub-flavored Markdown and get the
220    # version.
221    changelog = 'ChangeLog.rst'
222    changelog_path = os.path.join(fmt_repo.dir, changelog)
223    import rst2md
224    changes, version = rst2md.convert(changelog_path)
225    cmakelists = 'CMakeLists.txt'
226    for line in fileinput.input(os.path.join(fmt_repo.dir, cmakelists),
227                                inplace=True):
228        prefix = 'set(FMT_VERSION '
229        if line.startswith(prefix):
230            line = prefix + version + ')\n'
231        sys.stdout.write(line)
232
233    # Update the version in the changelog.
234    title_len = 0
235    for line in fileinput.input(changelog_path, inplace=True):
236        if line.decode('utf-8').startswith(version + ' - TBD'):
237            line = version + ' - ' + datetime.date.today().isoformat()
238            title_len = len(line)
239            line += '\n'
240        elif title_len:
241            line = '-' * title_len + '\n'
242            title_len = 0
243        sys.stdout.write(line)
244
245    # Add the version to the build script.
246    script = os.path.join('doc', 'build.py')
247    script_path = os.path.join(fmt_repo.dir, script)
248    for line in fileinput.input(script_path, inplace=True):
249      m = re.match(r'( *versions = )\[(.+)\]', line)
250      if m:
251        line = '{}[{}, \'{}\']\n'.format(m.group(1), m.group(2), version)
252      sys.stdout.write(line)
253
254    fmt_repo.checkout('-B', 'release')
255    fmt_repo.add(changelog, cmakelists, script)
256    fmt_repo.commit('-m', 'Update version')
257
258    # Build the docs and package.
259    run = Runner(fmt_repo.dir)
260    run('cmake', '.')
261    run('make', 'doc', 'package_source')
262    update_site(env)
263
264    # Create a release on GitHub.
265    fmt_repo.push('origin', 'release')
266    params = {'access_token': os.getenv('FMT_TOKEN')}
267    r = requests.post('https://api.github.com/repos/fmtlib/fmt/releases',
268                      params=params,
269                      data=json.dumps({'tag_name': version,
270                                       'target_commitish': 'release',
271                                       'body': changes, 'draft': True}))
272    if r.status_code != 201:
273        raise Exception('Failed to create a release ' + str(r))
274    id = r.json()['id']
275    uploads_url = 'https://uploads.github.com/repos/fmtlib/fmt/releases'
276    package = 'fmt-{}.zip'.format(version)
277    r = requests.post(
278        '{}/{}/assets?name={}'.format(uploads_url, id, package),
279        headers={'Content-Type': 'application/zip'},
280        params=params, data=open('build/fmt/' + package, 'rb'))
281    if r.status_code != 201:
282        raise Exception('Failed to upload an asset ' + str(r))
283
284
285if __name__ == '__main__':
286    args = docopt.docopt(__doc__)
287    if args.get('release'):
288        release(args)
289    elif args.get('site'):
290        update_site(create_build_env())
291