def run(self):
source = self.sources[0]
if not os.path.exists(source):
msg.info(_("{} not yet generated").format(msg.simplify(source)),
pkg="asymptote")
return True
os.rename(self.aux, self.bak)
msg.log(_("saving {} to {}").format(msg.simplify(self.aux),
msg.simplify(self.bak)),
pkg="asymptote")
ret = super(Shell_Restoring_Aux, self).run()
msg.log(_("restoring {} to {}").format(msg.simplify(self.aux),
msg.simplify(self.bak)),
pkg="asymptote")
os.rename(self.bak, self.aux)
return ret
def run (self):
source = self.sources [0]
if not os.path.exists (source):
msg.info(_("{} not yet generated").format (msg.simplify (source)),
pkg="asymptote")
return True
os.rename (self.aux, self.bak)
msg.log (_ ("saving {} to {}").format (msg.simplify (self.aux),
msg.simplify (self.bak)),
pkg="asymptote")
ret = super (Shell_Restoring_Aux, self).run ()
msg.log (_ ("restoring {} to {}").format (msg.simplify (self.aux),
msg.simplify (self.bak)),
pkg="asymptote")
os.rename (self.bak, self.aux)
return ret
def run (self):
# check if the input file exists. if not, refuse to run.
if not os.path.exists (self.sources[0]):
msg.info (_("input file for %s does not yet exist, deferring")
% self.tool, pkg="biblio")
return True
# command might have been updated in the mean time, so get it now
self.environ["BIBINPUTS"] = ":".join (self.bib_paths)
self.environ["BSTINPUTS"] = ":".join (self.bst_paths)
command = self.build_command ()
msg.progress (_("running: %s") % " ".join (command))
process = subprocess.Popen (command, stdin = self.devnull,
stdout = self.devnull, env = self.environ)
if process.wait() != 0:
msg.error (_("There were errors running %s.") % self.tool, pkg="biblio")
return False
return True
def build(self, env):
"""
Build the final product.
"""
srcname = env.main.sources[0]
# FIXME unindent, untangle
if True:
if self.force:
ret = env.main.make(True)
if ret != ERROR and env.final is not env.main:
ret = env.final.make()
else:
# This is a hack for the call to get_errors() below
# to work when compiling failed when using -f.
env.final.failed_dep = env.main.failed_dep
else:
ret = env.final.make(self.force)
if ret == ERROR:
msg.info(_("There were errors compiling %s.") % srcname)
number = self.max_errors
for err in env.final.failed().get_errors():
if number == 0:
msg.info(_("More errors."))
break
msg.display(**err)
number -= 1
rubber.util.abort_generic_error()
if ret == UNCHANGED:
msg(1, _("nothing to be done for %s") % srcname)
if self.warn:
# FIXME
log = env.main.log
if not env.main.parse_log():
msg.error(_("cannot read the log file"))
return 1
msg.display_all(
log.parse(boxes=self.warn_boxes,
refs=self.warn_refs,
warnings=self.warn_misc))
def build (self, env):
"""
Build the final product.
"""
srcname = env.main.sources[0]
# FIXME unindent, untangle
if True:
if self.force:
ret = env.main.make(True)
if ret != ERROR and env.final is not env.main:
ret = env.final.make()
else:
# This is a hack for the call to get_errors() below
# to work when compiling failed when using -f.
env.final.failed_dep = env.main.failed_dep
else:
ret = env.final.make(self.force)
if ret == ERROR:
msg.info(_("There were errors compiling %s.") % srcname)
number = self.max_errors
for err in env.final.failed().get_errors():
if number == 0:
msg.info(_("More errors."))
break
msg.display(**err)
number -= 1
rubber.util.abort_generic_error ()
if ret == UNCHANGED:
msg(1, _("nothing to be done for %s") % srcname)
if self.warn:
# FIXME
log = env.main.log
if not env.main.parse_log ():
msg.error(_("cannot read the log file"))
return 1
msg.display_all(log.parse(boxes=self.warn_boxes,
refs=self.warn_refs, warnings=self.warn_misc))
def run (self):
if not os.path.exists (self.cmd [1]):
msg.info (_ ("%s not yet generated" % self.cmd [1]))
return True
# No more settings are expected, we compute the
# command once and for all.
if self.command_env == None:
if self.cmd [0] == "makeindex":
self.cmd.extend (self.opts)
if self.style:
self.cmd.extend (["-s", self.style])
path_var = "INDEXSTYLE"
else: # self.cmd [0] == "texindy"
for opt in self.opts:
if opt == "-g":
if self.lang != "":
msg.warn(_("'language' overrides 'order german'"),
pkg="index")
else:
self.lang = "german-din"
else: # opt == "-l"
self.modules.append("letter-ordering")
msg.warn(_("use 'module letter-ordering' instead of 'order letter'"),
pkg="index")
for mod in self.modules:
self.cmd.extend(["--module", mod])
if self.lang:
self.cmd.extend(["--language", self.lang])
path_var = "XINDY_SEARCHPATH"
if self.path != []:
self.command_env = { path_var: ':'.join(self.path + [os.getenv(path_var, '')]) }
else:
self.command_env = {}
# The actual run.
return self.doc.env.execute(self.cmd, self.command_env) == 0
def execute(self, prog, env={}, pwd=None, out=None, kpse=0):
"""
Silently execute an external program. The `prog' argument is the list
of arguments for the program, `prog[0]' is the program name. The `env'
argument is a dictionary with definitions that should be added to the
environment when running the program. The standard output is passed
line by line to the `out' function (or discarded by default). If the
optional argument `kpse' is true, the error output is parsed and
messages from Kpathsea are processed (to indicate e.g. font
compilation), otherwise the error output is kept untouched.
"""
msg.info(_("executing: %s") % " ".join(prog))
if pwd:
msg.log(_(" in directory %s") % pwd)
if env != {}:
msg.log(_(" with environment: %r") % env)
progname = prog_available(prog[0])
if not progname:
msg.error(_("%s not found") % prog[0])
return 1
penv = os.environ.copy()
for (key, val) in env.items():
penv[key] = val
if kpse:
stderr = subprocess.PIPE
else:
stderr = None
process = Popen(prog,
executable=progname,
env=penv,
cwd=pwd,
stdin=devnull(),
stdout=subprocess.PIPE,
stderr=stderr)
if kpse:
def parse_kpse():
for line in process.stderr.readlines():
line = line.rstrip()
match = re_kpse.match(line)
if not match:
continue
cmd = match.group("cmd")
if self.kpse_msg.has_key(cmd):
msg.progress(match.expand(self.kpse_msg[cmd]))
else:
msg.progress(_("kpathsea running %s") % cmd)
t = threading.Thread(target=parse_kpse)
t.start()
#thread.start_new_thread(parse_kpse, ())
if out is not None:
for line in process.stdout.readlines():
out(line)
else:
process.stdout.readlines()
ret = process.wait()
msg.log(_("process %d (%s) returned %d") % (process.pid, prog[0], ret))
return ret
def execute (self, prog, env={}, pwd=None, out=None, kpse=0):
"""
Silently execute an external program. The `prog' argument is the list
of arguments for the program, `prog[0]' is the program name. The `env'
argument is a dictionary with definitions that should be added to the
environment when running the program. The standard output is passed
line by line to the `out' function (or discarded by default). If the
optional argument `kpse' is true, the error output is parsed and
messages from Kpathsea are processed (to indicate e.g. font
compilation), otherwise the error output is kept untouched.
"""
msg.info(_("executing: %s") % " ".join(prog))
if pwd:
msg.log(_(" in directory %s") % pwd)
if env != {}:
msg.log(_(" with environment: %r") % env)
progname = prog_available(prog[0])
if not progname:
msg.error(_("%s not found") % prog[0])
return 1
penv = os.environ.copy()
for (key,val) in env.items():
penv[key] = val
if kpse:
stderr = subprocess.PIPE
else:
stderr = None
process = Popen(prog,
executable = progname,
env = penv,
cwd = pwd,
stdin = devnull(),
stdout = subprocess.PIPE,
stderr = stderr)
if kpse:
def parse_kpse ():
for line in process.stderr.readlines():
line = line.rstrip()
match = re_kpse.match(line)
if not match:
continue
cmd = match.group("cmd")
if self.kpse_msg.has_key(cmd):
msg.progress(match.expand(self.kpse_msg[cmd]))
else:
msg.progress(_("kpathsea running %s") % cmd)
t = threading.Thread(target=parse_kpse)
t.start()
#thread.start_new_thread(parse_kpse, ())
if out is not None:
for line in process.stdout.readlines():
out(line)
else:
process.stdout.readlines()
ret = process.wait()
msg.log(_("process %d (%s) returned %d") % (process.pid, prog[0],ret))
return ret
def main (self, cmdline):
"""
Run Rubber for the specified command line. This processes each
specified source in order (for making or cleaning). If an error
happens while making one of the documents, the whole process stops.
The method returns the program's exit code.
"""
self.jobname = None
self.prologue = []
self.epilogue = []
self.clean = 0
self.force = 0
self.unsafe = False
self.warn = 0
self.warn_boxes = 0
self.warn_misc = 0
self.warn_refs = 0
self.place = "."
args = self.parse_opts(cmdline)
initial_dir = os.getcwd()
msg.cwd = os.path.join(initial_dir, "")
if self.place != "." and self.place is not None:
msg.path = self.place
self.place = os.path.abspath(self.place)
msg.log(_("This is Rubber version %s.") % version)
for srcname in args:
src = os.path.abspath(os.path.join(initial_dir, srcname))
# Go to the appropriate directory
try:
if self.place != ".":
if self.place is None:
msg.path = os.path.dirname(src)
os.chdir(os.path.dirname(src))
src = os.path.basename(src)
else:
os.chdir(self.place)
except OSError as e:
msg.error(_("Error changing to working directory: %s") % e.strerror)
return 1
# Check the source and prepare it for processing
env = Environment()
if env.set_source(src, jobname=self.jobname):
return 1
self.jobname = None
env.is_in_unsafe_mode_ = self.unsafe
if self.include_only is not None:
env.main.includeonly(self.include_only)
if self.clean:
if env.main.products == []:
msg.warn(_("there is no LaTeX source for %s") % srcname)
continue
else:
env.make_source()
saved_vars = env.main.vars
env.main.vars = Variables(saved_vars, { "cwd": initial_dir })
for dir in self.path:
env.main.do_path(dir)
for cmd in self.prologue:
cmd = parse_line(cmd, env.main.vars)
env.main.command(cmd[0], cmd[1:], {'file': 'command line'})
env.main.vars = saved_vars
env.main.parse()
saved_vars = env.main.vars
env.main.vars = Variables(saved_vars, { "cwd": initial_dir })
for cmd in self.epilogue:
cmd = parse_line(cmd, env.main.vars)
env.main.command(cmd[0], cmd[1:], {'file': 'command line'})
env.main.vars = saved_vars
if self.compress is not None:
last_node = env.final
filename = last_node.products[0]
if self.compress == 'gzip':
from rubber.converters.gz import GzipDep
env.final = GzipDep(env.depends,
filename + '.gz', filename)
elif self.compress == 'bzip2':
from rubber.converters.bzip2 import Bzip2Dep
env.final = Bzip2Dep(env.depends,
filename + '.bz2', filename)
# Compile the document
if self.clean:
env.final.clean()
continue
if self.force:
ret = env.main.make(True)
if ret != ERROR and env.final is not env.main:
ret = env.final.make()
else:
# This is a hack for the call to get_errors() below
# to work when compiling failed when using -f.
env.final.failed_dep = env.main.failed_dep
else:
ret = env.final.make(self.force)
if ret == ERROR:
msg.info(_("There were errors compiling %s.") % srcname)
number = self.max_errors
for err in env.final.failed().get_errors():
if number == 0:
msg.info(_("More errors."))
break
msg.display(**err)
number -= 1
return 1
if ret == UNCHANGED:
msg(1, _("nothing to be done for %s") % srcname)
if self.warn:
log = env.main.log
if log.read(env.main.target + ".log"):
msg.error(_("cannot read the log file"))
return 1
msg.display_all(log.parse(boxes=self.warn_boxes,
refs=self.warn_refs, warnings=self.warn_misc))
return 0
def info_log(self, act):
"""
Check for a log file and extract information from it if it exists,
accroding to the argument's value.
"""
log = self.env.main.log
if not self.env.main.parse_log():
msg.error(_("Parsing the log file failed"))
rubber.util.abort_generic_error()
if act == "boxes":
if not msg.display_all(log.get_boxes()):
msg.info(_("There is no bad box."))
elif act == "check":
if msg.display_all(log.get_errors()): return 0
msg.info(_("There was no error."))
if msg.display_all(log.get_references()): return 0
msg.info(_("There is no undefined reference."))
if not msg.display_all(log.get_warnings()):
msg.info(_("There is no warning."))
if not msg.display_all(log.get_boxes()):
msg.info(_("There is no bad box."))
elif act == "errors":
if not msg.display_all(log.get_errors()):
msg.info(_("There was no error."))
elif act == "refs":
if not msg.display_all(log.get_references()):
msg.info(_("There is no undefined reference."))
elif act == "warnings":
if not msg.display_all(log.get_warnings()):
msg.info(_("There is no warning."))
else:
sys.stderr.write(
_("\
I don't know the action `%s'. This should not happen.\n") % act)
return 1
return 0
def info_log (self, act):
"""
Check for a log file and extract information from it if it exists,
accroding to the argument's value.
"""
log = self.env.main.log
ret = log.read(self.env.main.target + ".log")
if ret == 1:
msg.error(_("The log file is invalid."))
return 1
elif ret == 2:
msg.error(_("There is no log file"))
return 1
if act == "boxes":
if not msg.display_all(log.get_boxes()):
msg.info(_("There is no bad box."))
elif act == "check":
if msg.display_all(log.get_errors()): return 0
msg.info(_("There was no error."))
if msg.display_all(log.get_references()): return 0
msg.info(_("There is no undefined reference."))
if not msg.display_all(log.get_warnings()):
msg.info(_("There is no warning."))
if not msg.display_all(log.get_boxes()):
msg.info(_("There is no bad box."))
elif act == "errors":
if not msg.display_all(log.get_errors()):
msg.info(_("There was no error."))
elif act == "refs":
if not msg.display_all(log.get_references()):
msg.info(_("There is no undefined reference."))
elif act == "warnings":
if not msg.display_all(log.get_warnings()):
msg.info(_("There is no warning."))
else:
sys.stderr.write(_("\
I don't know the action `%s'. This should not happen.\n") % act)
return 1
return 0
def info_log(self, act):
"""
Check for a log file and extract information from it if it exists,
accroding to the argument's value.
"""
log = self.env.main.log
ret = log.read(self.env.main.target + ".log")
if ret == 1:
msg.error(_("The log file is invalid."))
return 1
elif ret == 2:
msg.error(_("There is no log file"))
return 1
if act == "boxes":
if not msg.display_all(log.get_boxes()):
msg.info(_("There is no bad box."))
elif act == "check":
if msg.display_all(log.get_errors()): return 0
msg.info(_("There was no error."))
if msg.display_all(log.get_references()): return 0
msg.info(_("There is no undefined reference."))
if not msg.display_all(log.get_warnings()):
msg.info(_("There is no warning."))
if not msg.display_all(log.get_boxes()):
msg.info(_("There is no bad box."))
elif act == "errors":
if not msg.display_all(log.get_errors()):
msg.info(_("There was no error."))
elif act == "refs":
if not msg.display_all(log.get_references()):
msg.info(_("There is no undefined reference."))
elif act == "warnings":
if not msg.display_all(log.get_warnings()):
msg.info(_("There is no warning."))
else:
sys.stderr.write(
_("\
I don't know the action `%s'. This should not happen.\n") % act)
return 1
return 0
def info_log (self, act):
"""
Check for a log file and extract information from it if it exists,
accroding to the argument's value.
"""
log = self.env.main.log
if not self.env.main.parse_log ():
msg.error(_("Parsing the log file failed"))
rubber.util.abort_generic_error ()
if act == "boxes":
if not msg.display_all(log.get_boxes()):
msg.info(_("There is no bad box."))
elif act == "check":
if msg.display_all(log.get_errors()): return 0
msg.info(_("There was no error."))
if msg.display_all(log.get_references()): return 0
msg.info(_("There is no undefined reference."))
if not msg.display_all(log.get_warnings()):
msg.info(_("There is no warning."))
if not msg.display_all(log.get_boxes()):
msg.info(_("There is no bad box."))
elif act == "errors":
if not msg.display_all(log.get_errors()):
msg.info(_("There was no error."))
elif act == "refs":
if not msg.display_all(log.get_references()):
msg.info(_("There is no undefined reference."))
elif act == "warnings":
if not msg.display_all(log.get_warnings()):
msg.info(_("There is no warning."))
else:
sys.stderr.write(_("\
I don't know the action `%s'. This should not happen.\n") % act)
return 1
return 0
