forks/apenwarr-redo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
apenwarr-redo/redo/paths.py

51 lines
1.9 KiB
Python
Raw Normal View History

Add a bunch of missing python docstrings. This appeases pylint, so un-disable its docstring warning.
2018-12-14 08:38:53 +00:00
"""Code for manipulating file paths."""
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
import os
Switch to module-relative import syntax. Now that the python scripts are all in a "redo" python module, we can use the "new style" (ahem) package-relative imports. This appeases pylint, plus avoids confusion in case more than one package has similarly-named modules.
2018-12-05 02:34:36 -05:00
from . import env
from .logs import debug2
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
def _default_do_files(filename):
l = filename.split('.')
Move into the 21st century by fixing some pylint warnings.
2018-12-02 23:15:37 -05:00
for i in range(1, len(l)+1):
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
basename = '.'.join(l[:i])
ext = '.'.join(l[i:])
Move into the 21st century by fixing some pylint warnings.
2018-12-02 23:15:37 -05:00
if ext:
ext = '.' + ext
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
yield ("default%s.do" % ext), basename, ext
def possible_do_files(t):
Add a bunch of missing python docstrings. This appeases pylint, so un-disable its docstring warning.
2018-12-14 08:38:53 +00:00
"""Yield a list of tuples describing the .do file needed to build t."""
Move into the 21st century by fixing some pylint warnings.
2018-12-02 23:15:37 -05:00
dirname, filename = os.path.split(t)
env and env_init: Eliminate weird auto-initialization of globals. Merge the two files into env, and make each command explicitly call the function that sets it up in the way that's needed for that command. This means we can finally just import all the modules at the top of each file, without worrying about import order. Phew. While we're here, remove the weird auto-appending-'all'-to-targets feature in env.init(). Instead, do it explicitly, and only from redo and redo-ifchange, only if is_toplevel and no other targets are given.
2018-12-05 01:07:16 -05:00
yield (os.path.join(env.v.BASE, dirname), "%s.do" % filename,
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
'', filename, '')
# It's important to try every possibility in a directory before resorting
# to a parent directory. Think about nested projects: We don't want
# ../../default.o.do to take precedence over ../default.do, because
# the former one might just be an artifact of someone embedding my project
# into theirs as a subdir. When they do, my rules should still be used
# for building my project in *all* cases.
env and env_init: Eliminate weird auto-initialization of globals. Merge the two files into env, and make each command explicitly call the function that sets it up in the way that's needed for that command. This means we can finally just import all the modules at the top of each file, without worrying about import order. Phew. While we're here, remove the weird auto-appending-'all'-to-targets feature in env.init(). Instead, do it explicitly, and only from redo and redo-ifchange, only if is_toplevel and no other targets are given.
2018-12-05 01:07:16 -05:00
t = os.path.normpath(os.path.join(env.v.BASE, t))
Move into the 21st century by fixing some pylint warnings.
2018-12-02 23:15:37 -05:00
dirname, filename = os.path.split(t)
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
dirbits = dirname.split('/')
# since t is an absolute path, dirbits[0] is always '', so we don't
# need to count all the way down to i=0.
for i in range(len(dirbits), 0, -1):
If redo searched all the way up to /default.do, it would run ./default.do instead. This only happened if the containing project was buggy, ie. you tried to build a target that has no .do file available anywhere. However, it resulted in a confusing outcome for that case, where we'd run the wrong default.do file with the wrong parameters. Extended an existing test to catch this mistake.
2019-03-02 02:53:02 -05:00
basedir = '/'.join(dirbits[:i]) or '/'
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
subdir = '/'.join(dirbits[i:])
Move into the 21st century by fixing some pylint warnings.
2018-12-02 23:15:37 -05:00
for dofile, basename, ext in _default_do_files(filename):
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
yield (basedir, dofile,
subdir, os.path.join(subdir, basename), ext)
def find_do_file(f):
Move into the 21st century by fixing some pylint warnings.
2018-12-02 23:15:37 -05:00
for dodir, dofile, basedir, basename, ext in possible_do_files(f.name):
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
dopath = os.path.join(dodir, dofile)
debug2('%s: %s:%s ?\n' % (f.name, dodir, dofile))
if os.path.exists(dopath):
f.add_dep('m', dopath)
Move into the 21st century by fixing some pylint warnings.
2018-12-02 23:15:37 -05:00
return dodir, dofile, basedir, basename, ext
redo-whichdo: fix a bug where the last dir was checked twice, and add tests. When we can't find a .do file, we walk all the way back to the root directory. When that happens, the root directory is actually searched twice. This is harmless (since a .do file doesn't exist there anyway) but causes redo-whichdo to produce the wrong output. Also, add a test, which I forgot to do when writing whichdo in the first place. To make the test work from the root directory, we need a way to initialize redo without actually creating a .redo directory. Add a init_no_state() function for that purpose, and split the necessary path functions into their own module so we can avoid importing builder.py.
2018-10-30 23:23:04 -04:00
else:
f.add_dep('c', dopath)
Move into the 21st century by fixing some pylint warnings.
2018-12-02 23:15:37 -05:00
return None, None, None, None, None
Reference in a new issue Copy permalink