def test_sudo(self):
sh.aliases['sudo'] = sh.path.join(sh.pwd(), 'sudo')
old_path = sh.env.path
sh.env.path = []
self.assertRaises(OSError, sh.check_sudo)
sh.env.path = old_path
sh.stdin(six.b('#!/bin/bash\necho root')) > 'sudo'
self.assertEqual(sh.chmod('+x sudo').succeeded, True)
self.assertEqual(sh.check_sudo(), None)
def generate(arguments, filename):
if not os.path.isfile(filename):
mod = __import__(filename, globals(), locals(), [''])
filename = mod.__file__
name = mod.__name__
else:
dirname = os.path.dirname(filename)
sys.path.insert(0, dirname)
name = inspect.getmodulename(filename)
mod = __import__(name)
filenames = []
for k, v in mod.__dict__.items():
if getattr(v, 'console_script', False) is True:
filenames.append(k)
if arguments['--list-entry-points']:
for name in filenames:
print(('%s = %s:%s' % (name.replace('_', '-'),
mod.__name__, name)))
sys.exit(0)
dest = os.path.expanduser(arguments['--destination'])
sh.mkdir('-p', dest)
modules = [six, 'docopt', 'ConfigObject', sh] + arguments['<MODULE>']
modules = ''.join([encode_module(m) for m in modules])
for name in filenames:
script = os.path.join(dest, name.replace('_', '-'))
with open(script, 'w') as fd:
fd.write(SCRIPT_HEADER + modules + LOAD_MODULES)
fd.write(inspect.getsource(mod).replace('__main__',
'__chutified__'))
fd.write("if __name__ == '__main__':\n %s()\n" % name)
executable = sh.chmod('+x', script)
if executable:
print(executable.commands_line)
else:
print('failed to generate %s' % script)
def post_render(config):
target_directory = os.path.abspath(config.target_directory)
pkg = config.variables['package.directory']
pkg_dir = os.path.join(target_directory, pkg)
if not test.d(pkg_dir):
mkdir(pkg_dir)
with open(os.path.join(pkg_dir, '__init__.py'), 'wb') as fd:
fd.write('# package\n')
doc_root = os.path.join(target_directory, 'docs')
vars = config.variables
d = dict(path=doc_root, author=vars['author.name'],
project=vars['package.name'],
version='', ext_autodoc='y', ext_viewcode='y',
batchfile=False)
quickstart_do_prompt = quickstart.do_prompt
def do_prompt(d, key, text, default=None, validator=quickstart.nonempty):
print(key)
if key in use_defaults:
if default == 'y':
default = True
elif default == 'n':
default = False
d[key] = default
elif key not in d:
quickstart_do_prompt(d, key, text, default, validator)
quickstart.do_prompt = do_prompt
if not os.path.isdir(doc_root):
# launch sphinx
quickstart.ask_user(d)
quickstart.generate(d)
filename = os.path.join(doc_root, 'conf.py')
# patch some files
with open(filename, 'ab') as fd:
fd.write('''
html_theme = 'nature'
import pkg_resources
version = pkg_resources.get_distribution("%s").version
release = version
''' % vars['package.name'])
filename = os.path.join(doc_root, 'Makefile')
with open(filename, 'rb') as fd:
data = fd.read()
data = data.replace('sphinx-build', '../bin/sphinx-build')
with open(filename, 'wb') as fd:
fd.write(data)
# launch buildout
cd(target_directory)
if not test.f('bootstrap.py'):
wget('-O bootstrap.py',
'https://bootstrap.pypa.io/bootstrap-buildout.py') > 1
chmod('+x bootstrap.py')
sh.python('bootstrap.py --allow-site-packages') > 1
if test.f('bin/buildout'):
sh.python('bin/buildout') > 1
def chutify(args):
"""
Usage: %prog [options] [<location>]
Generate binary scripts from all @console_script contained in <location>
<location> can be a directory, a python file or a dotted name.
If <location> is .git then generate a pre-commit hook which generate script
from the current directory.
<location> and --destination can be set in a .chut file:
[chut]
destination = bin/
location = scripts
Options:
-l, --loop Generate scripts when the source change
-s NAME, --section NAME Use NAME section in .chut [default: chut]
--devel Install develop scripts in bin/
--upgrade Upgrade virtualenv dependencies
-d DIR, --destination=DIR Destination [default: dist/scripts]
-i X, --interpreter=X Python interpreter to use
-n X, --new-version=X Set new scripts version
%options-30s
"""
config = sh.ini(".chut")
if sh.env.git_dir: # pragma: no cover
cfg = config["githook"] or config[args["--section"]]
else:
cfg = config[args["--section"]]
interpreter = args["--interpreter"] or cfg.interpreter or "python"
if interpreter in ("2", "3"): # pragma: no cover
interpreter = "python" + interpreter
args["--interpreter"] = interpreter
location = args.get("<location>") or cfg.location or os.getcwd()
location = os.path.expanduser(location)
if location.endswith(".git"):
hooks = sh.path.join(location, "hooks")
hook = sh.path.join(hooks, "pre-commit")
args["destination"] = hooks
generator = sh.Generator(**args)
if not __file__.endswith("chutify"):
filename = __file__.replace(".pyc", ".py")
script = generator(filename)[0]
sh.mv(script, hook)
else: # pragma: no cover
# install git hook
sh.cp(__file__, hook)
executable = sh.chmod("+x", hook)
if executable:
print(executable.commands_line)
return 0
if cfg.destination and args["--destination"] == "dist/scripts":
args["--destination"] = cfg.destination
if os.path.isfile("setup.py"):
version = sh.grep("-E ^version setup.py")
if version:
version = str(version).split("=")[1].strip("'\" ")
if "dev" in version:
version = version.split("dev")[0].strip(".")
args["version"] = version
generator = sh.Generator(**args)
commands = cfg.run.as_list("\n")
commands = [c.strip() for c in commands if c.strip()]
def gen():
scripts = generator(location)
for cmd in commands:
print("$ %s" % cmd)
if " " in cmd:
binary, args = cmd.split(" ", 1)
sh[binary](args) > 2
else:
sh[cmd]() > 2
return scripts
if args["--loop"]: # pragma: no cover
import time
while True:
try:
gen()
time.sleep(0.1)
except KeyboardInterrupt:
return 0
else:
scripts = gen()
if sh.env.git_dir: # pragma: no cover
sh.git("add -f", *scripts) > 1
return 0
