ghp-import-0.4.1/0000755000076500000240000000000012301220175014204 5ustar davispstaff00000000000000ghp-import-0.4.1/ghp-import0000755000076500000240000001332212265305053016231 0ustar davispstaff00000000000000#! /usr/bin/env python # # This file is part of the ghp-import package released under # the Tumbolia Public License. See the LICENSE file for more # information. import optparse as op import os import subprocess as sp import sys import time import unicodedata __usage__ = "%prog [OPTIONS] DIRECTORY" if sys.version_info[0] == 3: def enc(text): if isinstance(text, bytes): return text return text.encode() def dec(text): if isinstance(text, bytes): return text.decode('utf-8') return text def write(pipe, data): try: pipe.stdin.write(data) except IOError as e: if e.errno != errno.EPIPE: raise else: def enc(text): if isinstance(text, unicode): return text.encode('utf-8') return text def dec(text): if isinstance(text, unicode): return text return text.decode('utf-8') def write(pipe, data): pipe.stdin.write(data) def normalize_path(path): # Fix unicode pathnames on OS X # See: http://stackoverflow.com/a/5582439/44289 if sys.platform == "darwin": return unicodedata.normalize("NFKC", dec(path)) return path def check_repo(parser): cmd = ['git', 'rev-parse'] p = sp.Popen(cmd, stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE) (ignore, error) = p.communicate() if p.wait() != 0: if not error: error = "Unknown Git error" error = error.decode("utf-8") if error.startswith("fatal: "): error = error[len("fatal: "):] parser.error(error) def try_rebase(remote, branch): cmd = ['git', 'rev-list', '--max-count=1', 'origin/%s' % branch] p = sp.Popen(cmd, stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE) (rev, ignore) = p.communicate() if p.wait() != 0: return True cmd = ['git', 'update-ref', 'refs/heads/%s' % branch, rev.strip()] if sp.call(cmd) != 0: return False return True def get_config(key): p = sp.Popen(['git', 'config', key], stdin=sp.PIPE, stdout=sp.PIPE) (value, stderr) = p.communicate() return value.strip() def get_prev_commit(branch): cmd = ['git', 'rev-list', '--max-count=1', branch, '--'] p = sp.Popen(cmd, stdin=sp.PIPE, stdout=sp.PIPE, stderr=sp.PIPE) (rev, ignore) = p.communicate() if p.wait() != 0: return None return rev.decode('utf-8').strip() def mk_when(timestamp=None): if timestamp is None: timestamp = int(time.time()) currtz = "%+05d" % (-1 * time.timezone / 36) # / 3600 * 100 return "%s %s" % (timestamp, currtz) def start_commit(pipe, branch, message): uname = dec(get_config("user.name")) email = dec(get_config("user.email")) write(pipe, enc('commit refs/heads/%s\n' % branch)) write(pipe, enc('committer %s <%s> %s\n' % (uname, email, mk_when()))) write(pipe, enc('data %d\n%s\n' % (len(message), message))) head = get_prev_commit(branch) if head: write(pipe, enc('from %s\n' % head)) write(pipe, enc('deleteall\n')) def add_file(pipe, srcpath, tgtpath): write(pipe, enc('M 100644 inline %s\n' % tgtpath)) with open(srcpath, "rb") as handle: data = handle.read() write(pipe, enc('data %d\n' % len(data))) write(pipe, enc(data)) write(pipe, enc('\n')) def add_nojekyll(pipe): write(pipe, enc('M 100644 inline .nojekyll\n')) write(pipe, enc('data 0\n')) write(pipe, enc('\n')) def gitpath(fname): norm = os.path.normpath(fname) return "/".join(norm.split(os.path.sep)) def run_import(srcdir, branch, message, nojekyll): cmd = ['git', 'fast-import', '--date-format=raw', '--quiet'] kwargs = {"stdin": sp.PIPE} if sys.version_info >= (3, 2, 0): kwargs["universal_newlines"] = False pipe = sp.Popen(cmd, **kwargs) start_commit(pipe, branch, message) for path, dnames, fnames in os.walk(srcdir): for fn in fnames: fpath = os.path.join(path, fn) fpath = normalize_path(fpath) gpath = gitpath(os.path.relpath(fpath, start=srcdir)) add_file(pipe, fpath, gpath) if nojekyll: add_nojekyll(pipe) write(pipe, enc('\n')) pipe.stdin.close() if pipe.wait() != 0: sys.stdout.write(enc("Failed to process commit.\n")) def options(): return [ op.make_option('-n', dest='nojekyll', default=False, action="store_true", help='Include a .nojekyll file in the branch.'), op.make_option('-m', dest='mesg', default='Update documentation', help='The commit message to use on the target branch.'), op.make_option('-p', dest='push', default=False, action='store_true', help='Push the branch to origin/{branch} after committing.'), op.make_option('-r', dest='remote', default='origin', help='The name of the remote to push to. [%default]'), op.make_option('-b', dest='branch', default='gh-pages', help='Name of the branch to write to. [%default]'), ] def main(): parser = op.OptionParser(usage=__usage__, option_list=options()) opts, args = parser.parse_args() if len(args) == 0: parser.error("No import directory specified.") if len(args) > 1: parser.error("Unknown arguments specified: %s" % ', '.join(args[1:])) if not os.path.isdir(args[0]): parser.error("Not a directory: %s" % args[0]) check_repo(parser) if not try_rebase(opts.remote, opts.branch): parser.error("Failed to rebase %s branch." % opts.branch) run_import(args[0], opts.branch, opts.mesg, opts.nojekyll) if opts.push: sp.check_call(['git', 'push', opts.remote, opts.branch]) if __name__ == '__main__': main() ghp-import-0.4.1/ghp_import.egg-info/0000755000076500000240000000000012301220175020046 5ustar davispstaff00000000000000ghp-import-0.4.1/ghp_import.egg-info/dependency_links.txt0000644000076500000240000000000112301220175024114 0ustar davispstaff00000000000000 ghp-import-0.4.1/ghp_import.egg-info/not-zip-safe0000644000076500000240000000000112173440647022313 0ustar davispstaff00000000000000 ghp-import-0.4.1/ghp_import.egg-info/PKG-INFO0000644000076500000240000001044112301220175021143 0ustar davispstaff00000000000000Metadata-Version: 1.0 Name: ghp-import Version: 0.4.1 Summary: Copy your docs directly to the gh-pages branch. Home-page: http://github.com/davisp/ghp-import Author: Paul Joseph Davis Author-email: paul.joseph.davis@gmail.com License: Tumbolia Public License Description: GitHub Pages Import =================== As part of [gunicorn][gunicorn], [Benoit Chesneau][benoit] and I have been starting to look at how to host documentation. There's the obvious method of using [GitHub's post-receive hook][github-post] to trigger doc builds and rsync to a webserver, but we ended up wanting to try out github's hosting to make the whole interface a bit more robust. [GitHub Pages][gh-pages] is a pretty awesome service that GitHub provides for hosting project documentation. The only thing is that it requires a `gh-pages` branch that is the site's document root. This means that keeping documentation sources in the branch with code is a bit difficult. And it really turns into a head scratcher for things like [Sphinx][sphinx] that want to access documentation sources and code sources at the same time. Then I stumbled across an interesting looking package called [github-tools][github-tools] that looked almost like what I wanted. It was a tad complicated and more involved than I wanted but it gave me an idear. Why not just write a script that can copy a directory to the `gh-pages` branch of the repository. This saves me from even having to think about the branch and everything becomes magical. This is what `ghp-import` was written for. [gunicorn]: http://www.gunicorn.com/ "Gunicorn" [benoit]: http://github.com/benoitc "Benoît Chesneau" [github-post]: https://help.github.com/articles/post-receive-hooks "GitHub Post-Receive Hook" [gh-pages]: http://pages.github.com/ "GitHub Pages" [sphinx]: http://sphinx.pocoo.org/ "Sphinx Documentation" [github-tools]: http://dinoboff.github.com/github-tools/ "github-tools" Big Fat Warning --------------- This will **DESTROY** your `gh-pages` branch. If you love it, you'll want to take backups before playing with this. This script assumes that `gh-pages` is 100% derivative. You should never edit files in your `gh-pages` branch by hand if you're using this script because you will lose your work. Usage ----- Usage: ghp-import [OPTIONS] DIRECTORY Options: -n Include a .nojekyll file in the branch. -m MESG The commit message to use on the target branch. -p Push the branch to origin/{branch} after committing. -r REMOTE The name of the remote to push to. [origin] -b BRANCH Name of the branch to write to. [gh-pages] -h, --help show this help message and exit Its pretty simple. Inside your repository just run `ghp-import $DOCS_DIR` where `$DOCS_DIR` is the path to the **built** documentation. This will write a commit to your `gh-pages` branch with the current documents in it. If you specify `-p` it will also attempt to push the `gh-pages` branch to GitHub. By default it'll just run `git push origin gh-pages`. You can specify a different remote using the `-r` flag. You can specify a different branch with `-b`. This is useful for user and organization page, which are served from the `master` branch. `ghp-import` also recognizes the `GIT_DIR` environment variable which can be useful for Git hooks. License ------- `ghp-import` is distributed under the Tumbolia Public License. See the LICENSE file for more information. Platform: UNKNOWN Classifier: Development Status :: 3 - Alpha Classifier: Intended Audience :: Developers Classifier: Natural Language :: English Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 ghp-import-0.4.1/ghp_import.egg-info/SOURCES.txt0000644000076500000240000000033212301220175021730 0ustar davispstaff00000000000000LICENSE MANIFEST.in README.md ghp-import setup.py ghp_import.egg-info/PKG-INFO ghp_import.egg-info/SOURCES.txt ghp_import.egg-info/dependency_links.txt ghp_import.egg-info/not-zip-safe ghp_import.egg-info/top_level.txtghp-import-0.4.1/ghp_import.egg-info/top_level.txt0000644000076500000240000000000112301220175022567 0ustar davispstaff00000000000000 ghp-import-0.4.1/LICENSE0000644000076500000240000000056312205173260015222 0ustar davispstaff00000000000000 Tumbolia Public License Copyright 2013, Paul Davis Copying and distribution of this file, with or without modification, are permitted in any medium without royalty provided the copyright notice and this notice are preserved. TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. opan saurce LOL ghp-import-0.4.1/MANIFEST.in0000644000076500000240000000004212205173260015743 0ustar davispstaff00000000000000include LICENSE include README.md ghp-import-0.4.1/PKG-INFO0000644000076500000240000001044112301220175015301 0ustar davispstaff00000000000000Metadata-Version: 1.0 Name: ghp-import Version: 0.4.1 Summary: Copy your docs directly to the gh-pages branch. Home-page: http://github.com/davisp/ghp-import Author: Paul Joseph Davis Author-email: paul.joseph.davis@gmail.com License: Tumbolia Public License Description: GitHub Pages Import =================== As part of [gunicorn][gunicorn], [Benoit Chesneau][benoit] and I have been starting to look at how to host documentation. There's the obvious method of using [GitHub's post-receive hook][github-post] to trigger doc builds and rsync to a webserver, but we ended up wanting to try out github's hosting to make the whole interface a bit more robust. [GitHub Pages][gh-pages] is a pretty awesome service that GitHub provides for hosting project documentation. The only thing is that it requires a `gh-pages` branch that is the site's document root. This means that keeping documentation sources in the branch with code is a bit difficult. And it really turns into a head scratcher for things like [Sphinx][sphinx] that want to access documentation sources and code sources at the same time. Then I stumbled across an interesting looking package called [github-tools][github-tools] that looked almost like what I wanted. It was a tad complicated and more involved than I wanted but it gave me an idear. Why not just write a script that can copy a directory to the `gh-pages` branch of the repository. This saves me from even having to think about the branch and everything becomes magical. This is what `ghp-import` was written for. [gunicorn]: http://www.gunicorn.com/ "Gunicorn" [benoit]: http://github.com/benoitc "Benoît Chesneau" [github-post]: https://help.github.com/articles/post-receive-hooks "GitHub Post-Receive Hook" [gh-pages]: http://pages.github.com/ "GitHub Pages" [sphinx]: http://sphinx.pocoo.org/ "Sphinx Documentation" [github-tools]: http://dinoboff.github.com/github-tools/ "github-tools" Big Fat Warning --------------- This will **DESTROY** your `gh-pages` branch. If you love it, you'll want to take backups before playing with this. This script assumes that `gh-pages` is 100% derivative. You should never edit files in your `gh-pages` branch by hand if you're using this script because you will lose your work. Usage ----- Usage: ghp-import [OPTIONS] DIRECTORY Options: -n Include a .nojekyll file in the branch. -m MESG The commit message to use on the target branch. -p Push the branch to origin/{branch} after committing. -r REMOTE The name of the remote to push to. [origin] -b BRANCH Name of the branch to write to. [gh-pages] -h, --help show this help message and exit Its pretty simple. Inside your repository just run `ghp-import $DOCS_DIR` where `$DOCS_DIR` is the path to the **built** documentation. This will write a commit to your `gh-pages` branch with the current documents in it. If you specify `-p` it will also attempt to push the `gh-pages` branch to GitHub. By default it'll just run `git push origin gh-pages`. You can specify a different remote using the `-r` flag. You can specify a different branch with `-b`. This is useful for user and organization page, which are served from the `master` branch. `ghp-import` also recognizes the `GIT_DIR` environment variable which can be useful for Git hooks. License ------- `ghp-import` is distributed under the Tumbolia Public License. See the LICENSE file for more information. Platform: UNKNOWN Classifier: Development Status :: 3 - Alpha Classifier: Intended Audience :: Developers Classifier: Natural Language :: English Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 3 ghp-import-0.4.1/README.md0000644000076500000240000000617412205173260015500 0ustar davispstaff00000000000000GitHub Pages Import =================== As part of [gunicorn][gunicorn], [Benoit Chesneau][benoit] and I have been starting to look at how to host documentation. There's the obvious method of using [GitHub's post-receive hook][github-post] to trigger doc builds and rsync to a webserver, but we ended up wanting to try out github's hosting to make the whole interface a bit more robust. [GitHub Pages][gh-pages] is a pretty awesome service that GitHub provides for hosting project documentation. The only thing is that it requires a `gh-pages` branch that is the site's document root. This means that keeping documentation sources in the branch with code is a bit difficult. And it really turns into a head scratcher for things like [Sphinx][sphinx] that want to access documentation sources and code sources at the same time. Then I stumbled across an interesting looking package called [github-tools][github-tools] that looked almost like what I wanted. It was a tad complicated and more involved than I wanted but it gave me an idear. Why not just write a script that can copy a directory to the `gh-pages` branch of the repository. This saves me from even having to think about the branch and everything becomes magical. This is what `ghp-import` was written for. [gunicorn]: http://www.gunicorn.com/ "Gunicorn" [benoit]: http://github.com/benoitc "Benoît Chesneau" [github-post]: https://help.github.com/articles/post-receive-hooks "GitHub Post-Receive Hook" [gh-pages]: http://pages.github.com/ "GitHub Pages" [sphinx]: http://sphinx.pocoo.org/ "Sphinx Documentation" [github-tools]: http://dinoboff.github.com/github-tools/ "github-tools" Big Fat Warning --------------- This will **DESTROY** your `gh-pages` branch. If you love it, you'll want to take backups before playing with this. This script assumes that `gh-pages` is 100% derivative. You should never edit files in your `gh-pages` branch by hand if you're using this script because you will lose your work. Usage ----- Usage: ghp-import [OPTIONS] DIRECTORY Options: -n Include a .nojekyll file in the branch. -m MESG The commit message to use on the target branch. -p Push the branch to origin/{branch} after committing. -r REMOTE The name of the remote to push to. [origin] -b BRANCH Name of the branch to write to. [gh-pages] -h, --help show this help message and exit Its pretty simple. Inside your repository just run `ghp-import $DOCS_DIR` where `$DOCS_DIR` is the path to the **built** documentation. This will write a commit to your `gh-pages` branch with the current documents in it. If you specify `-p` it will also attempt to push the `gh-pages` branch to GitHub. By default it'll just run `git push origin gh-pages`. You can specify a different remote using the `-r` flag. You can specify a different branch with `-b`. This is useful for user and organization page, which are served from the `master` branch. `ghp-import` also recognizes the `GIT_DIR` environment variable which can be useful for Git hooks. License ------- `ghp-import` is distributed under the Tumbolia Public License. See the LICENSE file for more information. ghp-import-0.4.1/setup.cfg0000644000076500000240000000007312301220175016025 0ustar davispstaff00000000000000[egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 ghp-import-0.4.1/setup.py0000644000076500000240000000162612301220140015713 0ustar davispstaff00000000000000import os import sys try: from setuptools import setup except ImportError: from distutils.core import setup LONG_DESC = open(os.path.join(os.path.dirname(__file__), "README.md")).read() setup( name = "ghp-import", version = "0.4.1", description = "Copy your docs directly to the gh-pages branch.", long_description = LONG_DESC, author = "Paul Joseph Davis", author_email = "paul.joseph.davis@gmail.com", license = "Tumbolia Public License", url = "http://github.com/davisp/ghp-import", zip_safe = False, classifiers = [ "Development Status :: 3 - Alpha", "Intended Audience :: Developers", 'Natural Language :: English', "Operating System :: OS Independent", "Programming Language :: Python", "Programming Language :: Python :: 2", "Programming Language :: Python :: 3", ], scripts = ['ghp-import'] )