def build_url(self, location, name):
location = location.parent
suffix = None
try:
target = self.pages[str(name)][0]
logger.debug('look up for %s: rendered output: %s', name, target)
suffix = '.html'
except KeyError:
for r in self.config.resources:
t = r.lookup_target(str(name))
if t is not None:
target = t
logger.debug('look up for %s: resources: %s', name, target)
break
else:
logger.warning('look up for %s: nothing found!', name)
return None
n = 0
for a, b in zip(location.parts, target.parts):
if a != b:
break
n += 1
newpath = ('..', ) * (len(location.parts) - n) + target.parts[n:]
p = PurePosixPath(*newpath)
if suffix is not None:
p = p.with_suffix(suffix)
if p.name == 'index.html':
return p.parent / '.'
if p.suffix == '.html' and self.config.htmlless:
p = p.with_suffix('')
return p
def build_url(self, location, name):
location = location.parent
suffix = None
try:
target = self.pages[str(name)][0]
logger.debug('look up for %s: rendered output: %s', name, target)
suffix = '.html'
except KeyError:
for r in self.config.resources:
t = r.lookup_target(str(name))
if t is not None:
target = t
logger.debug('look up for %s: resources: %s', name, target)
break
else:
logger.warning('look up for %s: nothing found!', name)
return None
n = 0
for a, b in zip(location.parts, target.parts):
if a != b:
break
n += 1
newpath = ('..',) * (len(location.parts) - n) + target.parts[n:]
p = PurePosixPath(*newpath)
if suffix is not None:
p = p.with_suffix(suffix)
if p.name == 'index.html':
return p.parent / '.'
if p.suffix == '.html' and self.config.htmlless:
p = p.with_suffix('')
return p
def get(self, path, root=None):
if isinstance(path, str) or isinstance(path, unicode):
path = PurePosixPath(path)
if isinstance(path, PurePath):
path = list(path.parts[1:] if path.is_absolute() else path.parts)
if root is None:
root = self.root
if not isinstance(root, dict):
root = {'?file': True, '?content': root}
if not path: # Check if reached the final location
return root
next_node = path[0]
path.pop(0)
if '?' in next_node:
return None
elif next_node in root:
if not isinstance(root[next_node], dict):
root[next_node] = {'?file': True, '?content': root[next_node]}
root[next_node]['?parent'] = root
return self.get(path, root[next_node])
else:
return None
def __init__(self, *a, indexes, source, root, index_root, **kw):
super().__init__(*a, **kw)
self.source = self._dir / source
self.root = PurePosixPath(root)
self.index_root = PurePosixPath(index_root)
self.indexes = indexes
self.by_name = {}
self.cats = {}
def split_filename_into_tokens(include_dir, filename, is_windows):
# type: (str, str, bool) -> Any
r"""
Tokens are the individual components of paths
Invalid Linux Tokens
'\0' (NUL)
Invalid Windows Tokens
< (less than)
> (greater than)
: (colon - sometimes works, but is actually NTFS Alternate Data Streams)
" (double quote)
/ (forward slash)
\ (backslash)
| (vertical bar or pipe)
? (question mark)
* (asterisk)
All control codes (<= 31)
"""
if is_windows:
inc = PureWindowsPath(include_dir)
pth = PureWindowsPath(filename).parts
# fails if the comment has stripped out the file (e.g., "INCLUDE '$ENV/model.bdf'")
pth0 = pth[0]
# Linux style paths
# /work/model.bdf
if len(pth0) == 1 and pth0[0] == '\\':
# utterly breaks os.path.join
raise SyntaxError('filename=%r cannot start with / on Windows' %
filename)
else:
inc = PurePosixPath(include_dir)
pth = PurePosixPath(filename).parts
# fails if the comment has stripped out the file (e.g., "INCLUDE '$ENV/model.bdf'")
pth0 = pth[0]
if len(pth0) >= 2 and pth0[:2] == r'\\':
# Windows network paths
# \\nas3\work\model.bdf
raise SyntaxError("filename=%r cannot start with \\\\ on Linux" %
filename)
pth2 = split_tokens(pth, is_windows)
if is_windows:
pth3 = ntpath.join(*pth2)
else:
pth3 = posixpath.join(*pth2)
pth_out = inc / pth3
return pth_out
def normalize_path(path):
"""
Convert a Path to a slash-separated string, suitable for use in cloud
object names. (We don't just use ``str(path)`` because our paths might
look different if we ever run on Windows.)
"""
return str(PurePosixPath(path))
def resolveTraversal(self, path):
path = PurePosixPath(path)
if not path.is_absolute():
return path
new_path = []
for node in path.parts:
if node == '.':
pass
elif node == '..':
if len(new_path) > 1:
new_path.pop()
else:
new_path.append(node)
return PurePosixPath(*new_path)
def _search_objects(target_dir, s3_objects, s3_obj_name='', ignore_pattern=''):
log.trace('_search_objects args: %s' % str({
'target_dir': target_dir,
's3_objects len': len(s3_objects),
's3_obj_name': s3_obj_name,
'ignore_pattern': ignore_pattern
}))
matched_objects = set()
for s3_obj in s3_objects:
s3_obj_path = PurePosixPath(s3_obj['Key'])
try:
obj_rel_path = s3_obj_path.relative_to(target_dir)
if (target_dir == s3_obj_path):
continue
except ValueError as e:
log.trace('_search_objects s3_obj not relative_to target_dir: %s' % e.message)
continue
try:
obj_next_path_list = target_dir.joinpath(obj_rel_path.parts[0])
except Exception as e:
log.fatal('Error in _search_objects: "%s"' % e.message)
log.fatal(str({
's3_obj_path': s3_obj_path,
'obj_rel_path': obj_rel_path,
'target_dir': target_dir
}))
exit(1)
obj_next_path_string = str(obj_next_path_list)
log.trace('_search_objects s3_obj_path: ' + str(s3_obj_path))
log.trace('_search_objects obj_next_path_string: ' + obj_next_path_string)
if ignore_pattern:
if re.search(ignore_pattern, s3_obj_path.name):
continue
if s3_obj_name:
# Look for matches to obj_name
if re.search(s3_obj_name, s3_obj_path.name):
matched_objects.add(s3_obj)
else:
matched_objects.add(obj_next_path_string)
results = sorted([obj for obj in matched_objects], reverse=True)
log.trace('_search_objects results: %s' % results)
return results
def update_or_clone(url,
name=None,
branch='master',
remote='origin',
display_status=False,
quiet=False): # pragma: no cover -- TODO commands
if not name:
name = PurePosixPath(url).name
if name.endswith('.git'):
name = name[:-4]
if not Path(name).is_dir():
subprocess.call(['git', 'clone', url, name])
else:
with clckwrkbdgr.fs.CurrentDir(name):
sync(quiet=quiet)
update(quiet=quiet)
return name
def _split_path(abspath, is_windows):
"""
Takes a path and splits it into the various components.
This is a helper method for ``write_include``
"""
if is_windows:
parts = PureWindowsPath(abspath).parts
else:
parts = PurePosixPath(abspath).parts
return parts
def __init__(self, *a, source, root, **kw):
super().__init__(*a, **kw)
self.source = self._dir / source
self.root = PurePosixPath(root)
self.sources = [
p for p in self.source.iterdir() if not self.is_ignored(p)
]
self.log(logging.INFO, 'Found %d sources in %s', len(self.sources),
self.source.resolve())
def do_GET(self): # pragma: no cover
path = self.path
if path.startswith('/'):
path = path[1:]
path_parts = list(map(six.moves.urllib.parse.unquote, PurePosixPath(path).parts))
full_path = self.server.config.root
if path_parts:
full_path = os.path.join(full_path, os.path.join(*path_parts))
if os.path.isfile(full_path):
self._respond(self.mod_file_response(200, full_path))
elif os.path.isdir(full_path):
self.serve_filesystem(full_path)
else:
self._respond(Response(404, 'Not Found'))
def __init__(self, *a, title, description, module, output, **kw):
super().__init__(*a, **kw)
self._info = {}
self.title = title
self.description = description
self.blog = self.config.module_id[module]
if not isinstance(self.blog, Blog):
self.log(
logging.WARNING,
"Configured with a target other than a blog. Expect errors.")
self.output = PurePosixPath(output)
def recursive_index_search(bucket, target_dir, root_dir, obj_name='', ignore_pattern=''):
log.trace('recursive_index_search args: %s' % locals())
s3_objects = _get_list_of_s3_objects(bucket, root_dir)
# Root dir not part of target dir will make pathlib throw
try:
rel_path = target_dir.relative_to(root_dir).parts
except ValueError as e:
log.fatal('Error with root dir and target dir: "%s"\n' % e.message)
exit(1)
objs_in_each_dir = []
objs_in_each_dir.append(
[root_dir, _search_objects(root_dir, s3_objects, obj_name, ignore_pattern)]
)
for index, _ in enumerate(rel_path):
target_dir_to_search = PurePosixPath(consts.aps.join(root_dir.parts + rel_path[:index + 1]))
objs = _search_objects(target_dir_to_search, s3_objects, obj_name, ignore_pattern)
objs_in_each_dir.append([target_dir_to_search, objs])
return objs_in_each_dir
def resolve(self, path_cur, path_next, path_home):
path_cur = PurePosixPath(path_cur)
path_next = PurePosixPath(path_next)
path_next_parts = path_next.parts
if not path_next_parts:
return None
path_new = None
if path_next.is_absolute():
path_new = path_next
elif path_next_parts[0] == '~':
path_new = PurePosixPath(path_home) / PurePosixPath(
*path_next_parts[1:])
else:
path_new = path_cur / path_next
path_new = self.resolveTraversal(path_new)
if not self.get(path_new) is None:
return str(path_new)
else:
return None
def parse_dir_name(raw_path):
path = PurePosixPath(raw_path)
if path.parts[0] == consts.aps:
path = PurePosixPath(consts.aps.join(path.parts[1:]))
return path
def split_tokens(tokens, is_windows):
"""converts a series of path tokens into a joinable path"""
tokens2 = []
is_mac_linux = not is_windows
for itoken, token in enumerate(tokens):
# this is technically legal...
# INCLUDE '/testdir/dir1/dir2/*/myfile.dat'
assert '*' not in token, '* in path not supported; tokens=%s' % tokens
if is_windows:
assert '$' not in token, '$ in path not supported; tokens=%s' % tokens
else:
assert '%' not in token, '%% in path not supported; tokens=%s' % tokens
if itoken == 0 and is_mac_linux and ':' in token:
## no C:/dir/model.bdf on linux/mac
#raise SyntaxError('token cannot include colons (:); token=%r; tokens=%s' % (
#token, str(tokens)))
# this has an environment variable or a drive letter
#print(token)
stokens = token.split(':')
if len(stokens) != 2:
msg = "len(stokens)=%s must be 2; stokens=%s" % (len(stokens), stokens)
raise SyntaxError(msg)
if len(stokens[0]) == 1:
if len(stokens[1]) not in [0, 1]:
raise SyntaxError('tokens=%r token=%r stokens=%s stoken[1]=%r len=%r' % (
tokens, token, stokens, stokens[1], len(stokens[1])))
if len(stokens[0]) < 2:
raise SyntaxError('token cannot include colons (:); token=%r; tokens=%s' % (
token, str(tokens)))
else:
# variables in Windows are not case sensitive; not handled?
token0 = stokens[0]
if is_windows:
assert '$' not in stokens[0], token0
assert '%' not in stokens[0], token0
if '%' in token0:
assert token0[0] == '%', token0
assert token0[-1] == '%', token0
token0 = '%' + token0 + '%'
else:
token0 = '$' + token0
#tokeni = os.path.expandvars('$' + stokens[0])
tokeni = os.path.expandvars(token0)
if '$' in tokeni:
raise SyntaxError('tokeni=%r has a $ in it after expanding (token0=%r)...\n'
'tokens=%s stokens=%s' % (tokeni, token0, tokens, stokens))
tokensi = PureWindowsPath(tokeni).parts
else:
if '$' in token0:
assert token0[0] == '$', token0
else:
token0 = '$' + token0
assert '%' not in stokens[0], token0
tokeni = os.path.expandvars(token0)
tokensi = PurePosixPath(tokeni).parts
tokens2.extend(tokensi)
tokens2.append(stokens[1])
elif ':' in token:
# Windows
# this has an environment variable or a drive letter
stokens = token.split(':')
if len(stokens[0]) == 1:
if len(stokens[1]) not in [0, 1]:
raise SyntaxError('tokens=%r token=%r stokens=%s stoken[1]=%r len=%r' % (
tokens, token, stokens, stokens[1], len(stokens[1])))
# drive letter
if itoken != 0:
raise SyntaxError('the drive letter is in the wrong place; '
'itoken=%s; token=%r; stoken=%s; tokens=%s' % (
itoken, token, stokens, tokens))
tokens2.append(token)
else:
# variables in Windows are not case sensitive; not handled?
environment_vars_to_expand = stokens[:-1]
if len(environment_vars_to_expand) != 1:
raise SyntaxError(
'Only 1 environment variable can be expanded; '
'environment_vars_to_expand = %r' % environment_vars_to_expand)
for env_var in environment_vars_to_expand:
if env_var.strip('$ %') not in os.environ:
environment_variables = list(os.environ.keys())
environment_variables.sort()
raise SyntaxError("Cant find environment variable=%r"
'\nenviron=%s' % (env_var, environment_variables))
env_vari = os.path.expandvars('$' + env_var.strip('%'))
if '$' in env_vari:
raise SyntaxError('env_vari=%r has a $ in it after expanding (token0=%r)...\n'
'tokens=%s stokens=%s' % (env_vari, env_var, tokens, stokens))
if is_windows:
tokensi = PureWindowsPath(env_vari).parts
else:
tokensi = PurePosixPath(env_vari).parts
tokens2.extend(tokensi)
tokens2.append(stokens[-1])
else:
# standard
tokens2.append(token)
return tokens2
def run(self, gen):
for link, template in self.mapping.items():
link = PurePosixPath(link)
def render(gs, template=template):
return gs.render_template(template)
gen.add_render(link, link, render)