def reset_pack(pack):
"""Resets a single pack. """
(pack, sep, pconfig) = pack.partition(":")
pack_setup = get_pack_setup(pack)
pack_dir = get_pack_dir(pack)
if not pack_setup:
return False
if not pack_setup.is_managed():
std("Pack", pack, "is marked as unmanaged, skipping reset. ")
return True
if not pack_setup.is_installed(pack_dir):
err("Pack", pack, "is not installed, skipping removal. ")
else:
if not remove_pack(pack + sep + pconfig):
err("Pack", pack, "could not be removed, --reset has failed. ")
return False
if not install_pack(pack + sep + pconfig):
err("Pack", pack, "could not be (re)installed, --reset has failed. ")
return False
return True
def update_pack(pack):
"""Updates a single pack. """
(pack, sep, pconfig) = pack.partition(":")
pack_setup = get_pack_setup(pack)
pack_dir = get_pack_dir(pack)
if not pack_setup:
return False
if not pack_setup.is_installed(pack_dir):
err("Pack", pack, "is not installed, can not update. ")
return False
if not pack_setup.is_managed():
std("Pack", pack, "is marked as unmanaged, skipping update. ")
return True
try:
return pack_setup.update(pack_dir, pconfig)
except classes.UnsupportedAction:
err("Pack", pack,
"does not support updating. You may want to --reset the pack. ")
return False
def do(args, unknown):
rep = match_repo(args.repo)
if rep == None:
err("Unable to find repository '"+args.repo+"' locally. ")
return False
# Create a generated instance.
gen = Generated(rep)
if args.branch == None and not args.list and not args.status:
err("Branch argument is required unless --list or --status is given. ")
return False
if args.install:
return gen.install_branch(args.branch)
if args.init:
return gen.init_branch(args.branch)
if args.pull:
return gen.pull_branch(args.branch)
if args.push:
return gen.push_branch(args.branch)
if args.list:
for b in gen.get_all_branches(tuple=False):
std(b)
return True
return gen.print_status()
def do(args, unknown):
rep = match_repo(args.repo)
if rep == None:
err("Unable to find repository '" + args.repo + "' locally. ")
return False
# Create a generated instance.
gen = Generated(rep)
if args.branch == None and not args.list and not args.status:
err("Branch argument is required unless --list or --status is given. ")
return False
if args.install:
return gen.install_branch(args.branch)
if args.init:
return gen.init_branch(args.branch)
if args.pull:
return gen.pull_branch(args.branch)
if args.push:
return gen.push_branch(args.branch)
if args.list:
for b in gen.get_all_branches(tuple=False):
std(b)
return True
return gen.print_status()
def reset_pack(pack):
"""Resets a single pack. """
(pack, sep, pconfig) = pack.partition(":")
pack_setup = get_pack_setup(pack)
pack_dir = get_pack_dir(pack)
if not pack_setup:
return False
if not pack_setup.is_managed():
std("Pack", pack, "is marked as unmanaged, skipping reset. ")
return True
if not pack_setup.is_installed(pack_dir):
err("Pack", pack, "is not installed, skipping removal. ")
else:
if not remove_pack(pack+sep+pconfig):
err("Pack", pack, "could not be removed, --reset has failed. ")
return False
if not install_pack(pack+sep+pconfig):
err("Pack", pack, "could not be (re)installed, --reset has failed. ")
return False
return True
def write_deps(dirname, deps):
"""Writes dependencies into a given module. """
f = lmh_locate("content", match_repo(dirname), "META-INF", "MANIFEST.MF")
n = re.sub(r"dependencies: (.*)", "dependencies: "+",".join(deps), read_file(f))
write_file(f, n)
std("Wrote new dependencies to", f)
def do(args, unknown):
if not args.no_check and not check_deps():
err("Dependency check failed. ")
err("Cannot perform specefied action. ")
err("Use --no-check to skip checking dependencies. ")
return False
if len(args.pack) == 0:
args.pack = ["default"]
if args.saction == "update":
# Update self as well when calling lmh setup --update
args.pack += ["self"]
if args.saction == "install":
return lmh.lib.packs.install(*args.pack)
elif args.saction == "update":
return lmh.lib.packs.update(*args.pack)
elif args.saction == "remove":
return lmh.lib.packs.remove(*args.pack)
elif args.saction == "reset":
return lmh.lib.packs.reset(*args.pack)
elif args.saction == "manage":
return lmh.lib.packs.manage(*args.pack)
elif args.saction == "unmanage":
return lmh.lib.packs.unmanage(*args.pack)
elif args.saction == "status":
return lmh.lib.packs.status(*args.pack)
else:
std("No setup action specefied, assuming --install. ")
std("Please specify some action in the future. ")
return lmh.lib.packs.install(*args.pack)
def remove_pack(pack):
"""Removes a single pack. """
(pack, sep, pconfig) = pack.partition(":")
pack_setup = get_pack_setup(pack)
pack_dir = get_pack_dir(pack)
if not pack_setup:
return False
if not pack_setup.is_installed(pack_dir):
err("Pack", pack, "is not installed, nothing to remove. ")
return True
if not pack_setup.is_managed():
std("Pack", pack, "is marked as unmanaged, skipping removal. ")
return True
try:
return pack_setup.remove(pack_dir, pconfig)
except classes.UnsupportedAction:
err("Pack", pack,
"does not support removal. Maybe you can remove it manually. ")
return False
def run_lmh_find_moved(find, replace):
if simulate:
# We will run it over dest only.
std("lmh", "find", json.dumps(find), "--replace", json.dumps(replace), "--apply", odest)
else:
# Append it to to a list.
local_finds.append(find)
local_replaces.append(replace)
def unmanage_pack(pack):
"""Marks a single pack as managed"""
(pack, sep, pconfig) = pack.partition(":")
std("Marked packaged '"+pack+"' as unamanged. ")
return get_pack_setup(pack).mark_unmanaged()
def unmanage_pack(pack):
"""Marks a single pack as managed"""
(pack, sep, pconfig) = pack.partition(":")
std("Marked packaged '" + pack + "' as unamanged. ")
return get_pack_setup(pack).mark_unmanaged()
def rm_untracked(file, t = ""):
if not is_tracked(file):
try:
os.remove(file)
std("Removed", t, file)
except:
err("Unable to remove", file)
return False
return True
def run_lmh_find_moved(find, replace):
if simulate:
# We will run it over dest only.
std("lmh", "find", json.dumps(find), "--replace",
json.dumps(replace), "--apply", odest)
else:
# Append it to to a list.
local_finds.append(find)
local_replaces.append(replace)
def do(cmd, args, *repos):
"""Does an arbitraty git commit on all repositories. """
ret = True
if args == None:
args = [""]
args = args[0].split(" ")
for rep in repos:
std("git "+cmd, args[0], rep)
ret = git_do(rep, cmd, *args) and ret
return ret
def do(args, unknown):
res = ls_remote(*args.spec)
if res == False:
return False
else:
for r in res:
if is_installed(r):
std(term_colors("green")+r+term_colors("normal"))
else:
std(term_colors("red")+r+term_colors("normal"))
return True
def do(args, unknown):
res = ls_remote(*args.spec)
if res == False:
return False
else:
for r in res:
if is_installed(r):
std(term_colors("green") + r + term_colors("normal"))
else:
std(term_colors("red") + r + term_colors("normal"))
return True
def list_config():
"""
Prints information about all available configuration settings to stdout.
"""
for key in sorted(config_meta.keys()):
try:
if config_meta[key]["hidden"]:
continue
except:
pass
std(key +" =", format_type(config_meta[key]["type"]), json.dumps(get_config(key)))
def list_config():
"""
Prints information about all available configuration settings to stdout.
"""
for key in sorted(config_meta.keys()):
try:
if config_meta[key]["hidden"]:
continue
except:
pass
std(key + " =", format_type(config_meta[key]["type"]),
json.dumps(get_config(key)))
def install(*reps):
"""Install a repositories and its dependencies"""
ret = True
reps = list(filter(lambda x:x, [r.strip() for r in reps]))
for rep in reps:
if not is_installed(rep):
std("Starting installation: ", term_colors("blue")+"'"+rep+"'"+term_colors("normal"))
(res, deps) = do_install(rep)
if not res:
err("Failed installation: ", term_colors("red")+"'"+rep+"'"+term_colors("normal"))
ret = False
else:
std("Finished installation: ", term_colors("green")+"'"+rep+"'"+term_colors("normal"))
reps.extend([d for d in deps if not d in reps])
else:
std("Re-scanning for dependencies: ", term_colors("blue")+"'"+rep+"'"+term_colors("normal"))
(res, deps) = do_deps_install(rep)
if not res:
err("Failed scan: ", term_colors("red")+"'"+rep+"'"+term_colors("normal"))
else:
std("Finished scan: ", term_colors("green")+"'"+rep+"'"+term_colors("normal"))
reps.extend([d for d in deps if not d in reps])
return ret
def pull(verbose, *repos):
"""Pulls all currently installed repositories and updates dependencies"""
# Check if we need to update the local repository
def needs_updating(rep):
rep = match_repo(rep, abs=True)
if verbose:
return True
state = get_remote_status(rep)
return state == "pull" or state == "failed" or state == "divergence"
ret = True
repos = list(filter(lambda x:x, [r.strip() for r in repos]))
for rep in repos:
std( "Starting update: ", term_colors("blue")+"'"+rep+"'"+term_colors("normal"))
if not do_pull(rep, needs_updating(rep)):
std("Update failed: ", term_colors("red")+"'"+rep+"'"+term_colors("normal"))
ret = False
else:
std("Update suceeded: ", term_colors("green")+"'"+rep+"'"+term_colors("normal"))
std("Re-installing updated repositories ...")
return ret and install(*repos)
def pull(verbose, *repos):
"""Pulls all currently installed repositories and updates dependencies"""
# Check if we need to update the local repository
def needs_updating(rep):
rep = match_repo(rep, abs=True)
if verbose:
return True
state = get_remote_status(rep)
return state == "pull" or state == "failed" or state == "divergence"
ret = True
repos = list(filter(lambda x: x, [r.strip() for r in repos]))
for rep in repos:
std("Starting update: ",
term_colors("blue") + "'" + rep + "'" + term_colors("normal"))
if not do_pull(rep, needs_updating(rep)):
std("Update failed: ",
term_colors("red") + "'" + rep + "'" + term_colors("normal"))
ret = False
else:
std("Update suceeded: ",
term_colors("green") + "'" + rep + "'" + term_colors("normal"))
std("Re-installing updated repositories ...")
return ret and install(*repos)
def find_and_replace_file(file, match, replace, replace_match = None):
"""Finds and replaces a single file. """
if len(match) != len(replace):
err("Find and Replace patterns are not of the same length. ")
return False
# Compile thex regexp
try:
match_regex = [re.compile(m) for m in match]
except Exception as e:
err(e)
err("Unable to compile regular expressions. ")
return False
# get the repository
repo = os.path.relpath(find_repo_dir(file), lmh_locate("content"))
# We did nothing yet
did = False
if replace_match == None:
def replace_match(match, replace):
# TODO: Migrate this to the parent scope.
# did = True
# Make a template,
replacer_template = {}
replacer_template["repo"] = repo
for i, g in enumerate(match.groups()):
replacer_template["g"+str(i)] = g
# And replace in it
return Template(replace).substitute(replacer_template)
# Read file and search
file_content = read_file(file)
new_file_content = file_content
# Iterate over the regexes and replace
for (m, r) in zip(match_regex, replace):
new_file_content = re.sub(m, lambda x:replace_match(x, r), new_file_content)
if file_content != new_file_content:
std(file)
# If something has changed, write back the file.
write_file(file, new_file_content)
if did:
std(file)
return did
def hook_post_install(rep):
"""
Hook that runs before installation of a repository.
"""
# Create an instance for the generated branch.
gen = Generated(rep)
# and install all of them.
for g in gen.get_all_branches(tuple=False):
std("Setting up generated branch '" + g + "'. ")
if not gen.install_branch(g):
return False
return hook_post_update(rep)
def hook_post_install(rep):
"""
Hook that runs before installation of a repository.
"""
# Create an instance for the generated branch.
gen = Generated(rep)
# and install all of them.
for g in gen.get_all_branches(tuple=False):
std("Setting up generated branch '"+g+"'. ")
if not gen.install_branch(g):
return False
return hook_post_update(rep)
def status_pack(pack):
"""Prints status of a pack"""
(pack, sep, pconfig) = pack.partition(":")
setup_pack = get_pack_setup(pack)
pack_dir = get_pack_dir(pack)
std("---")
std("Package", pack)
std("Installed:", setup_pack.is_installed(pack_dir))
std("Managed:", setup_pack.is_managed())
std("---")
return True
def status_pack(pack):
"""Prints status of a pack"""
(pack, sep, pconfig) = pack.partition(":")
setup_pack = get_pack_setup(pack)
pack_dir = get_pack_dir(pack)
std("---")
std("Package", pack)
std("Installed:", setup_pack.is_installed(pack_dir))
std("Managed:", setup_pack.is_managed())
std("---")
return True
def export(f=None):
"""Exports the list of currently installed repositories. """
# Get all locally installed directories
installed = match_repos(lmh_locate("content"))
if (f == None):
for mod in installed:
std(mod)
return True
try:
write_file(f, os.linesep.join(installed))
return True
except:
err("Unable to write %s" % f)
return False
def export(f = None):
"""Exports the list of currently installed repositories. """
# Get all locally installed directories
installed = match_repos(lmh_locate("content"))
if(f == None):
for mod in installed:
std(mod)
return True
try:
write_file(f, os.linesep.join(installed))
return True
except:
err("Unable to write %s" % f)
return False
def do(args, unknown):
url = get_config("mh::issue_url")
repo = match_repo(args.repo)
# if we can not match the repository, exit
if not repo:
err("Unable to match repository '"+repo+"'")
return False
# Try and open the url
# and if that fails, just print it.
url = url.replace("$name", repo)
if not webbrowser.open(url):
std(url)
return True
def add_symis(text, symis):
addtext = []
for sym in symis:
if sym[1] == 0:
continue
addtext.append("\\sym%s{%s}\n" % ("i"*sym[1], "}{".join(sym[2])))
# HACK: Print out the symbols we add
std(", ".join(addtext).replace("\n", ""))
addtext = remove_doubles(addtext)
pattern = r"\\begin{modsig}((.|\n)*)\\end{modsig}"
return re.sub(pattern, r"\\begin{modsig}\1"+"".join(addtext)+"\\end{modsig}", text)
def do(args, unknown):
url = get_config("mh::issue_url")
repo = match_repo(args.repo)
# if we can not match the repository, exit
if not repo:
err("Unable to match repository '" + repo + "'")
return False
# Try and open the url
# and if that fails, just print it.
url = url.replace("$name", repo)
if not webbrowser.open(url):
std(url)
return True
def add_symis(text, symis):
addtext = []
for sym in symis:
if sym[1] == 0:
continue
addtext.append("\\sym%s{%s}\n" % ("i" * sym[1], "}{".join(sym[2])))
# HACK: Print out the symbols we add
std(", ".join(addtext).replace("\n", ""))
addtext = remove_doubles(addtext)
pattern = r"\\begin{modsig}((.|\n)*)\\end{modsig}"
return re.sub(pattern,
r"\\begin{modsig}\1" + "".join(addtext) + "\\end{modsig}",
text)
def print_status(self):
"""
Prints some status information about the branches.
"""
std( "Repository Name: ", self.repo)
for (b, p) in self.get_all_branches():
std("Generated Branch: ", "'"+b+"'")
std("Path: ", "'"+p+"'")
std("Installed: ", "Yes" if self.is_installed(b) else "No")
def get_item_source(source_string, def_source, def_branch, name=""):
"""Gets the source branch and origin from a string and defaults. """
source = def_source
branch = def_branch
if not source_string == "":
index = source_string.find("@")
if index == 0:
branch = source_string[1:]
elif index > 0:
source = source_string[:index]
branch = source_string[index+1:]
else:
source = source_string
std("Using", name, "Version: "+source+"@"+branch)
return (source, branch)
def print_status(self):
"""
Prints some status information about the branches.
"""
std("Repository Name: ", self.repo)
for (b, p) in self.get_all_branches():
std("Generated Branch: ", "'" + b + "'")
std("Path: ", "'" + p + "'")
std("Installed: ",
"Yes" if self.is_installed(b) else "No")
def add_symbols(fname, warns=[]):
# Add missing symbols form language bindings to module
q = find_sds(fname, warns)
if len(q) == 1:
# we have already done something
return q[0]
(fmodname, defs, syms, symdefs, modcontent) = q
# check if we still need them
def need_sym(d):
# negated
req = ["sym", d[1], d[2]]
try:
name = "-".join(d[2])
except:
name = ""
# Normalise for issue #166
req[2] = "-".join(req[2]).split("-")
req[1] = len(req[2])
# We have an empty argument, what's this?
if name == "":
# it is empty
return False
return not ((req in syms) or (name in symdefs))
# OK filter them out
required = list(filter(need_sym, defs))
# Add them if we need to
if len(required) > 0:
std("Adding %s symbol definition(s) from %s: " %
(len(required), fname),
newline=False)
towrite = add_symis(modcontent, required)
std()
write_file(fmodname, towrite)
return True
def add_symbols(fname, warns=[]):
# Add missing symbols form language bindings to module
q = find_sds(fname, warns)
if len(q) == 1:
# we have already done something
return q[0]
(fmodname, defs, syms, symdefs, modcontent) = q
# check if we still need them
def need_sym(d):
# negated
req = ["sym", d[1], d[2]]
try:
name = "-".join(d[2])
except:
name = ""
# Normalise for issue #166
req[2] = "-".join(req[2]).split("-")
req[1] = len(req[2])
# We have an empty argument, what's this?
if name == "":
# it is empty
return False
return not ((req in syms) or (name in symdefs))
# OK filter them out
required = list(filter(need_sym, defs))
# Add them if we need to
if len(required) > 0:
std("Adding %s symbol definition(s) from %s: " % (len(required), fname), newline = False)
towrite = add_symis(modcontent, required)
std()
write_file(fmodname, towrite)
return True
def do(args, unknown):
if args.reset_all:
try:
os.remove(config.config_file)
return True
except:
pass
return False
if args.reset:
if args.key == None:
err("Missing key. ")
return False
try:
return config.reset_config(args.key)
except:
pass
return False
if args.key == None:
config.list_config()
std()
std("Type 'lmh config KEY' to get more information on KEY. ")
std("Type 'lmh config KEY VALUE' to change KEY to VALUE. ")
return True
elif args.value == None:
return config.get_config_help(args.key)
else:
try:
return config.set_config(args.key, args.value)
except:
pass
return False
def do(args, unknown):
if args.reset_all:
try:
os.remove(config.config_file)
return True
except:
pass
return False
if args.reset:
if args.key == None:
err("Missing key. ")
return False
try:
return config.reset_config(args.key)
except:
pass
return False
if args.key == None:
config.list_config()
std()
std("Type 'lmh config KEY' to get more information on KEY. ")
std("Type 'lmh config KEY VALUE' to change KEY to VALUE. ")
return True
elif args.value == None:
return config.get_config_help(args.key)
else:
try:
return config.set_config(args.key, args.value)
except:
pass
return False
def find_file(file, match):
"""Finds inside a single file. """
# Compile thex regexp
try:
match_regex = [re.compile(m) for m in match]
except Exception as e:
err(e)
err("Unable to compile regular expressions. ")
return False
# Read file and search
file_content = read_file(file)
ret = False
for i, m in enumerate(match_regex):
if re.search(m, file_content) != None:
if len(match) > 1:
std(str(i), file)
else:
std(file)
ret = True
return ret
def do_deps_install(rep):
"""
Runs a dependency check.
"""
std("Looking for dependencies ...")
deps = []
try:
for dep in get_package_dependencies(rep):
if not is_installed(dep):
std(" unsatisfied dependency: ", "'"+dep+"'")
else:
std(" satisfied dependency:", "'"+dep+"'")
deps.append(dep)
except Exception as e:
std(e)
err("Failed.")
return (False, deps)
std("Done. ")
return (True, deps)
def remove_pack(pack):
"""Removes a single pack. """
(pack, sep, pconfig) = pack.partition(":")
pack_setup = get_pack_setup(pack)
pack_dir = get_pack_dir(pack)
if not pack_setup:
return False
if not pack_setup.is_installed(pack_dir):
err("Pack", pack, "is not installed, nothing to remove. ")
return True
if not pack_setup.is_managed():
std("Pack", pack, "is marked as unmanaged, skipping removal. ")
return True
try:
return pack_setup.remove(pack_dir, pconfig)
except classes.UnsupportedAction:
err("Pack", pack, "does not support removal. Maybe you can remove it manually. ")
return False
def update_pack(pack):
"""Updates a single pack. """
(pack, sep, pconfig) = pack.partition(":")
pack_setup = get_pack_setup(pack)
pack_dir = get_pack_dir(pack)
if not pack_setup:
return False
if not pack_setup.is_installed(pack_dir):
err("Pack", pack, "is not installed, can not update. ")
return False
if not pack_setup.is_managed():
std("Pack", pack, "is marked as unmanaged, skipping update. ")
return True
try:
return pack_setup.update(pack_dir, pconfig)
except classes.UnsupportedAction:
err("Pack", pack, "does not support updating. You may want to --reset the pack. ")
return False
def commit(msg, verbose, *repos):
"""Commits all installed repositories """
ret = True
for rep in repos:
std("git commit", rep, "", newline=False)
if verbose or git_do_data(rep, "status", "--porcelain")[0] != "":
std()
ret = git_commit(rep, "-a", "-m", msg) and ret
else:
std("Ok, nothing to commit. ")
return ret
def get_config_help(key):
"""
Prints help to stdout about the given configuration settting.
"""
# check if the key exists
if not key in config_meta:
err("Option", key, " does not exist. ")
return False
# get its meta-information
meta = config_meta[key]
# and print that
std(format_type(meta["type"]), key)
std(meta["help"])
std("Current Value: " + json.dumps(get_config(key)))
std("Default Value: " + json.dumps(meta["default"]))
return True
def get_config_help(key):
"""
Prints help to stdout about the given configuration settting.
"""
# check if the key exists
if not key in config_meta:
err("Option", key, " does not exist. ")
return False
# get its meta-information
meta = config_meta[key]
# and print that
std(format_type(meta["type"]), key)
std(meta["help"])
std("Current Value: " + json.dumps(get_config(key)))
std("Default Value: " + json.dumps(meta["default"]))
return True
def do(args, unknown):
# If there are no repositories, check everything for dependencies.
if len(args.spec) == 0:
std("Nothing to install, re-installing all existing repositories. ")
return install(*match_repos(lmh_locate("content")))
if not get_config("install::noglobs"):
args.spec = ls_remote(*args.spec)
if len(args.spec) == 0:
err("Nothing to install...")
return True
if args.no_confirm_install:
std("Picked", len(args.spec),"repositories. ")
else:
std("Picked", len(args.spec),"repositories: ")
std(*args.spec)
if read_raw("Continue (y/N)?").lower() != "y":
err("Installation aborted. ")
return False
return install(*args.spec)
def push(verbose, *repos):
"""Pushes all currently installed repositories. """
# Check if we need to update the local repository
def needs_updating(rep):
state = get_remote_status(rep)
return state == "push" or state == "failed" or state == "divergence"
ret = True
repos = list(filter(lambda x:x, [r.strip() for r in repos]))
for rep in repos:
std("git push", rep, "", newline = False)
if verbose or needs_updating(rep):
std()
ret = git_push(rep) and ret
else:
std("OK, nothing to push. ")
return ret
def do(args, unknown):
if not webbrowser.open(get_config("gl::issue_url")):
std(get_config("gl::issue_url"))
return True
def init_branch(self, branch):
"""
Creates a new branch for status information.
"""
# Get name and path.
bsplit = branch.split(":")
if len(bsplit) == 1:
(name, pth) = (bsplit[0], bsplit[0])
else:
(name, pth) = (bsplit[0], bsplit[1])
std("Creating branch '" + name + "' at '" + pth + "'. ")
# Check if the branch already exists.
if name in self.get_all_branches(tuple=False):
err("Branch '" + name +
"' already exists, can not create it again. Use --install to install. "
)
return False
# Get the paths
rpath = match_repo(self.repo, abs=True)
dpath = os.path.join(rpath, pth)
meta_inf_path = os.path.join(rpath, "META-INF", "MANIFEST.MF")
# Find paths for the .gitignore
gitignore_path = os.path.join(rpath, ".gitignore")
gitignore_entry = os.path.join("/", pth) + "\n"
# and either add to it or create it.
if os.path.isfile(gitignore_path):
write_file(gitignore_path,
read_file(gitignore_path) + gitignore_entry)
else:
write_file(gitignore_path, gitignore_entry)
# Update the meta-inf
written = False
lines = get_metainf_lines(self.repo)
# try to append it to a line that already exists.
for (i, l) in enumerate(lines):
if l.startswith(gbranchstring):
lines[i] = lines[i].rstrip("\n") + " " + branch
written = True
break
# or make a new one.
if written == False:
lines.extend([gbranchstring + " " + branch])
# and write that file.
write_file(meta_inf_path, lines)
# Create the orphaned branch.
if not make_orphan_branch(rpath, name):
return False
# push it
if not do(rpath, "push", "-u", "origin", name):
err("Pushing branch to origin failed. ")
return False
# Clear the deploy branch cache for this repository.
self.clear_branch_cache()
# install it.
if not self.install_branch(name):
return False
# change the commit message
if not do(dpath, "commit", "--amend", "--allow-empty", "-m",
"Create deploy branch. "):
return False
# and push it.
if not do(dpath, "push", "--force", "origin", name):
return False
std("Generated files branch '" + name +
"' created, installed and pushed. ")
std("Please commit and push META-INF/MANIFEST.MF and .gitignore to publish installation. "
)
return True
def transmod(modname, org_lang, dest_lang, pre_terms = {}):
"""Translate a module from one language to another. """
# Load json from a file if pre_terms is a string
if type(pre_terms) == str:
try:
pre_terms = json.loads(read_file(pre_terms))
except:
try:
pre_terms = json.loads(pre_terms)
except:
err("Unable to load json in file %r" % pre_terms)
err("Make sure you have given a valid JSON-encoded string or path to a valid .json file. ")
return False
# Load the set of pre-translated terms
if org_lang in pre_terms:
pre_terms = pre_terms[org_lang]
if dest_lang in pre_terms:
pre_terms = pre_terms[dest_lang]
else:
pre_terms = {}
else:
pre_terms = {}
# filenames for the original + translated modules
orfn = "%s.%s.tex" % (modname, org_lang)
newfn = "%s.%s.tex" % (modname, dest_lang)
# read the original file
try:
content = read_file(orfn)
except:
err("Unable to read original module", orfn)
return False
#
# STEP 1: Replace the third argument to the modnl + viewnl environments
#
content = re.sub(r"(\\begin\{modnl\}\[[^\]]*\]\{[^\}]*\})\{"+org_lang+r"\}", r"\1{"+dest_lang+"}", content)
content = re.sub(r"(\\begin\{viewnl\}\[[^\]]*\]\{[^\}]*\})\{"+org_lang+r"\}", r"\1{"+dest_lang+"}", content)
#
# STEP 2: Update everything inside the environments
#
def replacer(match):
content = match.group(2)
# trefi -> mtrefi
content = re.sub(r"\\trefi\[([^\]]*)\]\{([^\}]*)\}", r"\\mtrefi[\1?\2]{\\ttl{\2}}", content)
# trefii -> mtrefii
content = re.sub(r"\\trefii\[([^\]]*)\]\{([^\}]*)\}\{([^\}]*)\}", r"\\mtrefii[\1?\2-\3]{\\ttl{\2 \3}}", content)
# trefiii -> mtrefiii
content = re.sub(r"\\trefiii\[([^\]]*)\]\{([^\}]*)\}\{([^\}]*)\}\{([^\}]*)\}", r"\\mtrefiii[\1?\2-\3-\4]{\\ttl{\2 \3 \4}}", content)
# defi
content = re.sub(r"\\defi\[([^\]]*)\]\{([^\}]*)\}", r"\\defi[\1]{\\ttl{\2}}", content)
content = re.sub(r"\\defi\{([^\}]*)\}", r"\\defi[\1]{\\ttl{\1}}", content)
# defii
content = re.sub(r"\\defii\[([^\]]*)\]\{([^\}]*)\}\{([^\}]*)\}", r"\\defii[\1]{\\ttl{\2}}{\\ttl{\3}}", content)
content = re.sub(r"\\defii\{([^\}]*)\}\{([^\}]*)\}", r"\\defii[\1-\2]{\\ttl{\1}}{\\ttl{\2}}", content)
# defiii
content = re.sub(r"\\defiii\[([^\]]*)\]\{([^\}]*)\}\{([^\}]*)\}\{([^\}]*)\}", r"\\defiii[\1]{\\ttl{\2}}{\\ttl{\3}}{\\ttl{\4}}", content)
content = re.sub(r"\\defiii\{([^\}]*)\}\{([^\}]*)\}\{([^\}]*)\}", r"\\defiii[\1-\2-\3]{\\ttl{\1}}{\\ttl{\2}}{\\ttl{\3}}", content)
def inner_supper(m):
# Inner replacement function
# Inserts the \ttl before any trailing whitespace.
(sub_inner, n) = re.subn(r"([\n\f\t\v\s]+)$", r"}\1", m.group(1))
if n == 0:
sub_inner+="}"
return r"\ttl{"+sub_inner+m.group(6)
def supper(m):
# Outer replacement function.
toreplace = m.group(4)
if re.match(r"^([\n\f\t\v\s]*)$", toreplace):
# we are only whitespaces => do nothing
pass
else:
# we are ntop only whitespaces => replace some sentences.
toreplace = re.sub(r"(((\w)+\s+)*((\w)+\s*))([\.\!\?\,\;]?)", inner_supper, toreplace)
return m.group(1)+toreplace+m.group(5)
# Replace non-wrapped text fragments
content = re.sub(r"((\]|\}|\$[^\$]*\$)(\w*))([^\\\{\}\$\]\[]+)(\s*)", supper, content)
# and return the content
return match.group(1)+content+match.group(4)
# Replace text inside the environments of modnl and viewnl
content = re.sub(r"(\\begin{modnl})((.|\n)*)(\\end{modnl})", replacer, content)
content = re.sub(r"(\\begin{viewnl})((.|\n)*)(\\end{viewnl})", replacer, content)
#
# STEP 3: Apply the pre-translated directory to \ttl{...}
#
# Replace all the technical terms
def replacer2(match):
# prefer full matches
if match.groups(1)[0] in pre_terms:
return match.groups(1)[0][pre_terms]
# Split the terms and look check if we can translate them
terms = []
for t in match.groups(1)[0].split(" "):
if t in pre_terms:
terms.append((pre_terms[t], True))
else:
terms.append((t, False))
# Put the results back together
result = ""
is_open_ttl = False
# For each of the terms
for (r, s) in terms:
if not is_open_ttl:
# We do not have an openn ttl
if s:
result+=r+" "
else:
result+="\\ttl{"+r+" "
is_open_ttl = True
else:
# We do have an open ttl
if s:
result += result[:-1]+"} "+r+" "
is_open_ttl = False
else:
result += r+" "
# Close the last bracket if needed
result = result[:-1]
if is_open_ttl:
result +="}"
return result
content = re.sub(r"\\ttl\{([^\}]*)\}", replacer2, content)
# write back the file
try:
write_file(newfn, content)
except:
err("Unable to write new module", newfn)
return False
# and do some logging
std("Prepared translation of", modname, "from")
std(orfn)
std("to")
std(newfn)
std("Please finish the translation and then commit the module. ")
# we need it for the return code
return True
def create_multi(modname, pre_terms, *langs):
if len(langs) == 0:
err("You need to create at least one language. ")
return False
lang = langs[0]
# Read the module
try:
content = read_file(modname+".tex")
except:
err("Unable to read original module", modname+".tex")
return False
# Module content
module_content_regex = r"^((?:.|\n)*)\\begin\{module\}\[(?:(.*),\s*)?id=([^,\]]*)(?:\s*(.*))\]((?:.|\n)*?)\\end\{module\}((?:.|\n)*)$"
module_move_regex = r"(\\(?:gimport|symdef|symtest|symvariant|symi+)(?:(?:\[(?:[^\]])*\])|(?:\{(?:[^\}])*\}))*((\n|$|\s)?))"
# Find the module
mod_content = re.findall(module_content_regex, content)
if len(mod_content) != 1:
err("Expected exactly one module environment. (Is the module really monolingual?)")
return False
mod_content = mod_content[0]
# Main Language Content
main_module = ""
main_language = ""
# Prefix and suffix to add to the module
mod_prefix = mod_content[0]
mod_suffix = mod_content[5]
# Id of the module
mod_id = mod_content[2]
mod_meta = mod_content[1]+mod_content[3]
if mod_meta != "":
mod_meta = "["+mod_meta+"]"
# We only want to move these
module_to_move = "".join([m[0] for m in re.findall(module_move_regex, mod_content[4])])
module_keep = re.sub(module_move_regex, lambda match:match.group(2), mod_content[4])
# Assemble the main module
main_module = mod_prefix
main_module += "\\begin{modsig}"+mod_meta+"{"+mod_id+"}"
main_module += module_to_move
main_module += "\\end{modsig}"
main_module += mod_suffix
try:
write_file(modname+".tex", main_module)
except:
err("Unable to write", modname+".tex")
return False
# Assemble the main language binding
main_language = mod_prefix
main_language += "\\begin{modnl}"+mod_meta+"{"+mod_id+"}{"+lang+"}\n"
main_language += module_keep
main_language += "\n\\end{modnl}"
main_language += mod_suffix
try:
write_file(modname+"."+lang+".tex", main_language)
except:
err("Unable to write", modname+"."+lang+".tex")
return False
lmh.lib.io.__supressStd__ = True
# Add the symbols frome the language file name
add_symbols(modname+"."+lang+".tex")
# Translate to all the other languages
for l in langs[1:]:
if not transmod(modname, lang, l, pre_terms = pre_terms):
lmh.lib.io.__supressStd__ = False
return False
lmh.lib.io.__supressStd__ = False
std("Created multilingual module", modname+".tex")
# Thats it.
return True
def do(args, unknown):
std("lmh, Version", about.version(), "( git", about.git_version(), ")")
std()
std(about.license_text())
return True
def do_pull(rep, needs_update):
"""
Actually pulls a repository.
"""
# pre-installation hook.
std("Running pre-update hook for '" + rep + "' ... ", newline=False)
if not hook_pre_pull(rep):
err("Failed. ")
return (False, [])
std("Done. ")
ret = True
if needs_update:
std("Running git pull ...")
rgp = git_pull(match_repo(rep, abs=True))
ret = rgp and ret
if rgp:
std("OK")
else:
err("Failed (merge conflicts or network issues?)")
ret = False
else:
std("Nothing to pull ...")
std("Running post-update hook for '" + rep + "' ... ", newline=False)
if not hook_post_pull(rep):
err("Failed. ")
return (False, [])
std("Done. ")
return ret
